﻿using static Vanara.PInvoke.Kernel32;
using USN = System.Int64;

namespace Vanara.PInvoke;

/// <summary>Functions, structures and constants from CldApi.dll.</summary>
public static partial class CldApi
{
	private const int CF_MAX_PROVIDER_NAME_LENGTH = 255;

	private const int CF_MAX_PROVIDER_VERSION_LENGTH = 255;

	/// <summary>Callback flags for canceling data fetching for a placeholder file or folder.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_cancel_flags typedef enum CF_CALLBACK_CANCEL_FLAGS
	// { CF_CALLBACK_CANCEL_FLAG_NONE, CF_CALLBACK_CANCEL_FLAG_IO_TIMEOUT, CF_CALLBACK_CANCEL_FLAG_IO_ABORTED } ;
	[PInvokeData("cfapi.h", MSDNShortId = "16F0BB1E-FB9E-4AC3-8FD9-A540F72F1155")]
	[Flags]
	public enum CF_CALLBACK_CANCEL_FLAGS
	{
		/// <summary>No cancel flag.</summary>
		CF_CALLBACK_CANCEL_FLAG_NONE = 0,

		/// <summary>Flag to be set if the user request is cancelled as a result of the expiration of the 60 second timer.</summary>
		CF_CALLBACK_CANCEL_FLAG_IO_TIMEOUT = 1,

		/// <summary>
		/// Flag to be set if the user request is cancelled as a result of the user explicitly terminating the hydration from
		/// app-initiated download toast.
		/// </summary>
		CF_CALLBACK_CANCEL_FLAG_IO_ABORTED = 2,
	}

	/// <summary>
	/// Callback flags for notifying a sync provider that a placeholder under one of its sync roots that has been previously opened for
	/// read/write/delete access is now closed.
	/// </summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_close_completion_flags typedef enum
	// CF_CALLBACK_CLOSE_COMPLETION_FLAGS { CF_CALLBACK_CLOSE_COMPLETION_FLAG_NONE, CF_CALLBACK_CLOSE_COMPLETION_FLAG_DELETED } ;
	[PInvokeData("cfapi.h", MSDNShortId = "D80D95FB-C53B-4A31-97B9-389BE73BE966")]
	[Flags]
	public enum CF_CALLBACK_CLOSE_COMPLETION_FLAGS
	{
		/// <summary>No close completion flags.</summary>
		CF_CALLBACK_CLOSE_COMPLETION_FLAG_NONE = 0,

		/// <summary>A flag set if a placeholder is deleted as a result of the close.</summary>
		CF_CALLBACK_CLOSE_COMPLETION_FLAG_DELETED = 1,
	}

	/// <summary>
	/// A callback flag to inform the sync provider that a placeholder under one of its sync roots has been successfully dehydrated.
	/// </summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_dehydrate_completion_flags typedef enum
	// CF_CALLBACK_DEHYDRATE_COMPLETION_FLAGS { CF_CALLBACK_DEHYDRATE_COMPLETION_FLAG_NONE,
	// CF_CALLBACK_DEHYDRATE_COMPLETION_FLAG_BACKGROUND, CF_CALLBACK_DEHYDRATE_COMPLETION_FLAG_DEHYDRATED } ;
	[PInvokeData("cfapi.h", MSDNShortId = "BB39BC4D-A5FF-4204-A7ED-30605B865F15")]
	[Flags]
	public enum CF_CALLBACK_DEHYDRATE_COMPLETION_FLAGS
	{
		/// <summary>No dehydration completion flag.</summary>
		CF_CALLBACK_DEHYDRATE_COMPLETION_FLAG_NONE = 0,

		/// <summary>A flag set if the dehydration request is initiated by a system background service.</summary>
		CF_CALLBACK_DEHYDRATE_COMPLETION_FLAG_BACKGROUND = 1,

		/// <summary>A flag set if the placeholder was hydrated prior to the dehydration request.</summary>
		CF_CALLBACK_DEHYDRATE_COMPLETION_FLAG_DEHYDRATED = 2,
	}

	/// <summary>Callback flags for notifying a sync provider that a placeholder under one of its sync root is going to be dehydrated.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_dehydrate_flags typedef enum
	// CF_CALLBACK_DEHYDRATE_FLAGS { CF_CALLBACK_DEHYDRATE_FLAG_NONE, CF_CALLBACK_DEHYDRATE_FLAG_BACKGROUND } ;
	[PInvokeData("cfapi.h", MSDNShortId = "DCB085EA-1468-44FB-9D45-F5C89693CBE7")]
	[Flags]
	public enum CF_CALLBACK_DEHYDRATE_FLAGS
	{
		/// <summary>No dehydrate flag.</summary>
		CF_CALLBACK_DEHYDRATE_FLAG_NONE = 0,

		/// <summary>A flag set if the dehydration request is initiated by a system background service.</summary>
		CF_CALLBACK_DEHYDRATE_FLAG_BACKGROUND = 1,
	}

	/// <summary/>
	[PInvokeData("cfapi.h")]
	public enum CF_CALLBACK_DEHYDRATION_REASON
	{
		/// <summary/>
		CF_CALLBACK_DEHYDRATION_REASON_NONE,

		/// <summary/>
		CF_CALLBACK_DEHYDRATION_REASON_USER_MANUAL,

		/// <summary/>
		CF_CALLBACK_DEHYDRATION_REASON_SYSTEM_LOW_SPACE,

		/// <summary/>
		CF_CALLBACK_DEHYDRATION_REASON_SYSTEM_INACTIVITY,

		/// <summary/>
		CF_CALLBACK_DEHYDRATION_REASON_SYSTEM_OS_UPGRADE,
	}

	/// <summary>Callback flags for notifying a sync provider that a placeholder was successfully deleted.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_delete_completion_flags typedef enum
	// CF_CALLBACK_DELETE_COMPLETION_FLAGS { CF_CALLBACK_DELETE_COMPLETION_FLAG_NONE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "33971B32-C97B-4C79-B6ED-B2E1C20B912A")]
	[Flags]
	public enum CF_CALLBACK_DELETE_COMPLETION_FLAGS
	{
		/// <summary>No delete completion flag.</summary>
		CF_CALLBACK_DELETE_COMPLETION_FLAG_NONE = 0,
	}

	/// <summary>
	/// This callback is used to inform the sync provider that a placeholder file or directory under one of its sync roots is about to
	/// be deleted.
	/// </summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_delete_flags typedef enum CF_CALLBACK_DELETE_FLAGS
	// { CF_CALLBACK_DELETE_FLAG_NONE, CF_CALLBACK_DELETE_FLAG_IS_DIRECTORY } ;
	[PInvokeData("cfapi.h", MSDNShortId = "76F9FB0C-F531-447F-8F0E-1EB849336771")]
	[Flags]
	public enum CF_CALLBACK_DELETE_FLAGS
	{
		/// <summary>No delete flag.</summary>
		CF_CALLBACK_DELETE_FLAG_NONE = 0,

		/// <summary>The placeholder that is about to be deleted is a directory.</summary>
		CF_CALLBACK_DELETE_FLAG_IS_DIRECTORY = 1,
	}

	/// <summary>Callback flags for fetching data for a placeholder file or folder.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_fetch_data_flags typedef enum
	// CF_CALLBACK_FETCH_DATA_FLAGS { CF_CALLBACK_FETCH_DATA_FLAG_NONE, CF_CALLBACK_FETCH_DATA_FLAG_RECOVERY,
	// CF_CALLBACK_FETCH_DATA_FLAG_EXPLICIT_HYDRATION } ;
	[PInvokeData("cfapi.h", MSDNShortId = "18C2CF8D-C59F-4181-953E-84B6BEC5F479")]
	[Flags]
	public enum CF_CALLBACK_FETCH_DATA_FLAGS
	{
		/// <summary>No data fetch flag.</summary>
		CF_CALLBACK_FETCH_DATA_FLAG_NONE = 0,

		/// <summary>Flag to be used if the callback is invoked as a result of previously interrupted hydration process.</summary>
		CF_CALLBACK_FETCH_DATA_FLAG_RECOVERY = 1,

		/// <summary>
		/// Note This value is new for Windows 10, version 1803. Flag to be used if the callback is invoked as a result of a call to CfHydratePlaceholder.
		/// </summary>
		CF_CALLBACK_FETCH_DATA_FLAG_EXPLICIT_HYDRATION = 2,
	}

	/// <summary>Flags for fetching information about the content of a placeholder file or directory.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_fetch_placeholders_flags typedef enum
	// CF_CALLBACK_FETCH_PLACEHOLDERS_FLAGS { CF_CALLBACK_FETCH_PLACEHOLDERS_FLAG_NONE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "CD90EB49-8C39-49DD-8688-CBDF77B1EA92")]
	[Flags]
	public enum CF_CALLBACK_FETCH_PLACEHOLDERS_FLAGS
	{
		/// <summary>No fetch placeholder flags.</summary>
		CF_CALLBACK_FETCH_PLACEHOLDERS_FLAG_NONE = 0,
	}

	/// <summary>Callback flags for notifying a sync provider that a placeholder was successfully opened for read/write/delete access.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_open_completion_flags typedef enum
	// CF_CALLBACK_OPEN_COMPLETION_FLAGS { CF_CALLBACK_OPEN_COMPLETION_FLAG_NONE, CF_CALLBACK_OPEN_COMPLETION_FLAG_PLACEHOLDER_UNKNOWN,
	// CF_CALLBACK_OPEN_COMPLETION_FLAG_PLACEHOLDER_UNSUPPORTED } ;
	[PInvokeData("cfapi.h", MSDNShortId = "FF7EA010-B90A-46F8-A373-5C128B31FE70")]
	[Flags]
	public enum CF_CALLBACK_OPEN_COMPLETION_FLAGS
	{
		/// <summary>No open completion flag.</summary>
		CF_CALLBACK_OPEN_COMPLETION_FLAG_NONE = 0,

		/// <summary>A flag set if the placeholder metadata is corrupted.</summary>
		CF_CALLBACK_OPEN_COMPLETION_FLAG_PLACEHOLDER_UNKNOWN = 1,

		/// <summary>A flag set if the placeholder metadata is not supported.</summary>
		CF_CALLBACK_OPEN_COMPLETION_FLAG_PLACEHOLDER_UNSUPPORTED = 2,
	}

	/// <summary>
	/// A callback flag to inform the sync provider that a placeholder under one of its sync roots has been successfully renamed.
	/// </summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_rename_completion_flags typedef enum
	// CF_CALLBACK_RENAME_COMPLETION_FLAGS { CF_CALLBACK_RENAME_COMPLETION_FLAG_NONE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "60C94543-E0C4-4A79-BBE3-3098401B1123")]
	[Flags]
	public enum CF_CALLBACK_RENAME_COMPLETION_FLAGS
	{
		/// <summary>No rename completion flag.</summary>
		CF_CALLBACK_RENAME_COMPLETION_FLAG_NONE = 0,
	}

	/// <summary>
	/// Call back flags to inform the sync provider that a placeholder under one of its sync roots is about to be renamed or moved.
	/// </summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_rename_flags typedef enum CF_CALLBACK_RENAME_FLAGS
	// { CF_CALLBACK_RENAME_FLAG_NONE, CF_CALLBACK_RENAME_FLAG_IS_DIRECTORY, CF_CALLBACK_RENAME_FLAG_SOURCE_IN_SCOPE,
	// CF_CALLBACK_RENAME_FLAG_TARGET_IN_SCOPE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "7506ED1D-F6A8-49EB-B03B-B629264DFBB2")]
	[Flags]
	public enum CF_CALLBACK_RENAME_FLAGS
	{
		/// <summary>No rename flag.</summary>
		CF_CALLBACK_RENAME_FLAG_NONE = 0,

		/// <summary>Flag set if the placeholder is a directory.</summary>
		CF_CALLBACK_RENAME_FLAG_IS_DIRECTORY = 1,

		/// <summary>Flag set if the link to be renamed or moved is within a sync root managed by the sync process.</summary>
		CF_CALLBACK_RENAME_FLAG_SOURCE_IN_SCOPE = 2,

		/// <summary>Flag set if the rename or move target is in the same sync root of the source path.</summary>
		CF_CALLBACK_RENAME_FLAG_TARGET_IN_SCOPE = 4,
	}

	/// <summary>Contains the various types of callbacks used on placeholder files or folders.</summary>
	/// <remarks>
	/// <para>
	/// These are not APIs provided by the library, but rather callbacks that a sync provider must implement in order to service
	/// requests from the platform. As necessary, the platform will ask the library instance running inside the sync provider process to
	/// invoke the appropriate callback routine.
	/// </para>
	/// <para>
	/// Callback routines will be invoked in an arbitrary thread (part of a thread pool). Multiple callbacks can occur simultaneously,
	/// in different threads, and it is the responsibility of the sync provider code to implement any necessary synchronization to make
	/// this work reliably. All callbacks are asynchronous. Asynchronous user requests that trigger the callbacks are pended and the
	/// control is returned to the user application.
	/// </para>
	/// <para>
	/// Every callback request has a fixed 60 second timeout. A valid operation on any pending requests from the sync provider resets
	/// the timers of all pending requests.
	/// </para>
	/// <para>
	/// All callback functions have the same prototype with two arguments: a CF_CALLBACK_INFO structure and a CF_CALLBACK_PARAMETER structure.
	/// </para>
	/// <para>Callback routines have no return value.</para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_type typedef enum CF_CALLBACK_TYPE {
	// CF_CALLBACK_TYPE_FETCH_DATA, CF_CALLBACK_TYPE_VALIDATE_DATA, CF_CALLBACK_TYPE_CANCEL_FETCH_DATA,
	// CF_CALLBACK_TYPE_FETCH_PLACEHOLDERS, CF_CALLBACK_TYPE_CANCEL_FETCH_PLACEHOLDERS, CF_CALLBACK_TYPE_NOTIFY_FILE_OPEN_COMPLETION,
	// CF_CALLBACK_TYPE_NOTIFY_FILE_CLOSE_COMPLETION, CF_CALLBACK_TYPE_NOTIFY_DEHYDRATE, CF_CALLBACK_TYPE_NOTIFY_DEHYDRATE_COMPLETION,
	// CF_CALLBACK_TYPE_NOTIFY_DELETE, CF_CALLBACK_TYPE_NOTIFY_DELETE_COMPLETION, CF_CALLBACK_TYPE_NOTIFY_RENAME,
	// CF_CALLBACK_TYPE_NOTIFY_RENAME_COMPLETION, CF_CALLBACK_TYPE_NONE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "0BA978D3-110C-47FC-8949-C5D98A59654C")]
	[Flags]
	public enum CF_CALLBACK_TYPE : uint
	{
		/// <summary>Callback to satisfy an I/O request, or a placeholder hydration request.</summary>
		CF_CALLBACK_TYPE_FETCH_DATA,

		/// <summary>Callback to validate placeholder data.</summary>
		CF_CALLBACK_TYPE_VALIDATE_DATA,

		/// <summary>Callback to cancel an ongoing placeholder hydration.</summary>
		CF_CALLBACK_TYPE_CANCEL_FETCH_DATA,

		/// <summary>Callback to request information about the contents of placeholder files.</summary>
		CF_CALLBACK_TYPE_FETCH_PLACEHOLDERS,

		/// <summary>Callback to cancel a request for the contents of placeholder files.</summary>
		CF_CALLBACK_TYPE_CANCEL_FETCH_PLACEHOLDERS,

		/// <summary>
		/// Callback to inform the sync provider that a placeholder under one of its sync roots has been successfully opened for
		/// read/write/delete access.
		/// </summary>
		CF_CALLBACK_TYPE_NOTIFY_FILE_OPEN_COMPLETION,

		/// <summary>
		/// Callback to inform the sync provider that a placeholder under one of its sync roots that has been previously opened for
		/// read/write/delete access is now closed.
		/// </summary>
		CF_CALLBACK_TYPE_NOTIFY_FILE_CLOSE_COMPLETION,

		/// <summary>Callback to inform the sync provider that a placeholder under one of its sync roots is about to be dehydrated.</summary>
		CF_CALLBACK_TYPE_NOTIFY_DEHYDRATE,

		/// <summary>Callback to inform the sync provider that a placeholder under one of its sync roots has been successfully dehydrated.</summary>
		CF_CALLBACK_TYPE_NOTIFY_DEHYDRATE_COMPLETION,

		/// <summary>Callback to inform the sync provider that a placeholder under one of its sync roots is about to be deleted.</summary>
		CF_CALLBACK_TYPE_NOTIFY_DELETE,

		/// <summary>Callback to inform the sync provider that a placeholder under one of its sync roots has been successfully deleted.</summary>
		CF_CALLBACK_TYPE_NOTIFY_DELETE_COMPLETION,

		/// <summary>
		/// Callback to inform the sync provider that a placeholder under one of its sync roots is about to be renamed or moved.
		/// </summary>
		CF_CALLBACK_TYPE_NOTIFY_RENAME,

		/// <summary>
		/// Callback to inform the sync provider that a placeholder under one of its sync roots has been successfully renamed or moved.
		/// </summary>
		CF_CALLBACK_TYPE_NOTIFY_RENAME_COMPLETION,

		/// <summary>No callback type.</summary>
		CF_CALLBACK_TYPE_NONE = 0xffffffff,
	}

	/// <summary>Flags to validate the data of a placeholder file or directory.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_validate_data_flags typedef enum
	// CF_CALLBACK_VALIDATE_DATA_FLAGS { CF_CALLBACK_VALIDATE_DATA_FLAG_NONE, CF_CALLBACK_VALIDATE_DATA_FLAG_EXPLICIT_HYDRATION } ;
	[PInvokeData("cfapi.h", MSDNShortId = "D5BEAEAA-318E-4BA5-8DC5-EDD24E2C26EF")]
	[Flags]
	public enum CF_CALLBACK_VALIDATE_DATA_FLAGS
	{
		/// <summary>No data validation flag.</summary>
		CF_CALLBACK_VALIDATE_DATA_FLAG_NONE = 0,

		/// <summary>
		/// Note This value is new for Windows 10, version 1803.Set if the callback is invoked as a result of a call to CfHydratePlaceholder.
		/// </summary>
		CF_CALLBACK_VALIDATE_DATA_FLAG_EXPLICIT_HYDRATION = 2,
	}

	/// <summary>Additional information that can be requested by a sync provider when its callbacks are invoked.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_connect_flags typedef enum CF_CONNECT_FLAGS {
	// CF_CONNECT_FLAG_NONE, CF_CONNECT_FLAG_REQUIRE_PROCESS_INFO, CF_CONNECT_FLAG_REQUIRE_FULL_FILE_PATH,
	// CF_CONNECT_FLAG_BLOCK_SELF_IMPLICIT_HYDRATION } ;
	[PInvokeData("cfapi.h", MSDNShortId = "C1CAC75C-9CB6-4172-A437-AE366D99DA9F")]
	[Flags]
	public enum CF_CONNECT_FLAGS
	{
		/// <summary>No connection flags.</summary>
		CF_CONNECT_FLAG_NONE = 0,

		/// <summary>
		/// When this flag is specified, the platform returns the full image path of the hydrating process in the callback parameters.
		/// </summary>
		CF_CONNECT_FLAG_REQUIRE_PROCESS_INFO = 2,

		/// <summary>
		/// When this flag is specified, the platform returns the full path of the placeholder being requested in the callback parameters.
		/// </summary>
		CF_CONNECT_FLAG_REQUIRE_FULL_FILE_PATH = 4,

		/// <summary>
		/// Note This value is new for Windows 10, version 1803.When this flag is specified, The implicit hydration, which is not
		/// performed via CfHydratePlaceholder, can happen when the anti-virus software scans a sync provider’s file system activities
		/// on non-hydrated cloud file placeholders. This kind of implicit hydration is not expected. If the sync provider never
		/// initiates implicit hydration operations, it can instruct the platform to block all such implicit hydration operations, as
		/// opposed to failing the FETCH_DATA callbacks later.
		/// </summary>
		CF_CONNECT_FLAG_BLOCK_SELF_IMPLICIT_HYDRATION = 8,
	}

	/// <summary>Normal file/directory to placeholder file/directory conversion flags.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_convert_flags typedef enum CF_CONVERT_FLAGS {
	// CF_CONVERT_FLAG_NONE, CF_CONVERT_FLAG_MARK_IN_SYNC, CF_CONVERT_FLAG_DEHYDRATE, CF_CONVERT_FLAG_ENABLE_ON_DEMAND_POPULATION } ;
	[PInvokeData("cfapi.h", MSDNShortId = "0342BF0B-509A-4F8D-9557-54E534A3DDFE")]
	[Flags]
	public enum CF_CONVERT_FLAGS
	{
		/// <summary>No conversion flags.</summary>
		CF_CONVERT_FLAG_NONE = 0,

		/// <summary>The platform marks the converted placeholder as in sync with cloud upon a successful conversion of the file.</summary>
		CF_CONVERT_FLAG_MARK_IN_SYNC = 1,

		/// <summary>
		/// Applicable to files only. When specified, the platform dehydrates the file after converting it to a placeholder
		/// successfully. The caller must acquire an exclusive handle when specifying this flag or data corruptions can occur. Note that
		/// the platform does not validate the exclusiveness of the handle.
		/// </summary>
		CF_CONVERT_FLAG_DEHYDRATE = 2,

		/// <summary>
		/// Applicable for directories only. When specified, it marks the converted placeholder directory as partially populated such
		/// that any future access to it will result in a FETCH_PLACEHOLDERS callback sent to the sync provider.
		/// </summary>
		CF_CONVERT_FLAG_ENABLE_ON_DEMAND_POPULATION = 4,
	}

	/// <summary>Flags for creating a placeholder file or directory.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_create_flags typedef enum CF_CREATE_FLAGS {
	// CF_CREATE_FLAG_NONE, CF_CREATE_FLAG_STOP_ON_ERROR } ;
	[PInvokeData("cfapi.h", MSDNShortId = "F70ECFDB-8542-4395-9EDD-7DABC2E5225D")]
	[Flags]
	public enum CF_CREATE_FLAGS
	{
		/// <summary>Default mode. All entries are processed.</summary>
		CF_CREATE_FLAG_NONE = 0,

		/// <summary>
		/// Causes the API to return immediately if placeholder creation fails. If creation fails, the error code will be returned by
		/// the API.
		/// </summary>
		CF_CREATE_FLAG_STOP_ON_ERROR = 1,
	}

	/// <summary>Placeholder dehydration flags.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_dehydrate_flags typedef enum CF_DEHYDRATE_FLAGS {
	// CF_DEHYDRATE_FLAG_NONE, CF_DEHYDRATE_FLAG_BACKGROUND } ;
	[PInvokeData("cfapi.h", MSDNShortId = "AE8AA67D-F6ED-4A2B-8613-17BBAB4C9F54")]
	[Flags]
	public enum CF_DEHYDRATE_FLAGS
	{
		/// <summary>No dehydration flags.</summary>
		CF_DEHYDRATE_FLAG_NONE = 0,

		/// <summary>
		/// If specified, the caller is a system process running in the background. Otherwise, the caller is performing this operation
		/// on behalf of a logged-in user.
		/// </summary>
		CF_DEHYDRATE_FLAG_BACKGROUND = 1,
	}

	/// <summary>Specifies whether or not hard links are allowed on placeholder files.</summary>
	/// <remarks>
	/// If hard links are enabled, applications can create as many hard links as the file system supports so long as the links are under
	/// the same sync root or no sync root. Hard links and placeholder operations that are not compatible with this policy will fail
	/// with the error: HRESULT(ERROR_CLOUD_FILES_INCOMPATIBLE_HARDLINKS).
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_hardlink_policy typedef enum CF_HARDLINK_POLICY {
	// CF_HARDLINK_POLICY_NONE, CF_HARDLINK_POLICY_ALLOWED } ;
	[PInvokeData("cfapi.h", MSDNShortId = "23FFC4E8-0CB7-4FF4-A3C3-2E8FB2C74497")]
	[Flags]
	public enum CF_HARDLINK_POLICY
	{
		/// <summary/>
		CF_HARDLINK_POLICY_NONE = 0,

		/// <summary>Hard links can be created on a placeholder under the same sync root or no sync root.</summary>
		CF_HARDLINK_POLICY_ALLOWED = 1,
	}

	/// <summary>Placeholder data hydration flags.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_hydrate_flags typedef enum CF_HYDRATE_FLAGS {
	// CF_HYDRATE_FLAG_NONE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "1D49752C-2D80-4EC8-AE24-2DEAFCB7FD46")]
	[Flags]
	public enum CF_HYDRATE_FLAGS
	{
		/// <summary>No hydration flags.</summary>
		CF_HYDRATE_FLAG_NONE = 0,
	}

	/// <summary>
	/// Allows a sync provider to control how placeholder files should be hydrated by the platform. This is a modifier that can be used
	/// with the primary policy: CF_HYDRATION_POLICY_PRIMARY.
	/// </summary>
	/// <remarks>
	/// In general, modifiers can be mixed and matched with any primary policy (CF_HYDRATION_POLICY_PRIMARY) and other policy modifiers
	/// so long as the combination is not self-conflicting.
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_hydration_policy_modifier typedef enum
	// CF_HYDRATION_POLICY_MODIFIER { CF_HYDRATION_POLICY_MODIFIER_NONE, CF_HYDRATION_POLICY_MODIFIER_VALIDATION_REQUIRED,
	// CF_HYDRATION_POLICY_MODIFIER_STREAMING_ALLOWED, CF_HYDRATION_POLICY_MODIFIER_AUTO_DEHYDRATION_ALLOWED } ;
	[PInvokeData("cfapi.h", MSDNShortId = "A98C635E-7E18-4E18-B19A-D3FD85A53CBB")]
	[Flags]
	public enum CF_HYDRATION_POLICY_MODIFIER : ushort
	{
		/// <summary>No policy modifier.</summary>
		CF_HYDRATION_POLICY_MODIFIER_NONE = 0,

		/// <summary>
		/// This policy modifier offers two guarantees to a sync provider. First, it guarantees that the data returned by the sync
		/// provider is always persisted to the disk prior to it being returned to the user application. Second, it allows the sync
		/// provider to retrieve the same data it has returned previously to the platform and validate its integrity. Only upon a
		/// successful confirmation of the integrity by the sync provider will the platform complete the user I/O request. This modifier
		/// helps support end-to-end data integrity at the cost of extra disk I/Os.
		/// </summary>
		CF_HYDRATION_POLICY_MODIFIER_VALIDATION_REQUIRED = 1,

		/// <summary>
		/// This policy modifier grants the platform the permission to not store any data returned by a sync provider on local disks.
		/// This policy modifier is ineffective when being combined with CF_HYDRATION_POLICY_MODIFIER_VALIDATION_REQUIRED.
		/// </summary>
		CF_HYDRATION_POLICY_MODIFIER_STREAMING_ALLOWED = 2,

		/// <summary>
		/// Note This value is new for Windows 10, version 1803.This policy modifier grants the platform the permission to dehydrate
		/// in-sync cloud file placeholders without the help of sync providers. Without this flag, the platform is not allowed to call
		/// CfDehydratePlaceholder directly. Instead, the only supported way to dehydrate a cloud file placeholder is to clear the
		/// file’s pinned attribute and set the file’s unpinned attribute. At that point, the actual dehydration will be performed
		/// asynchronously by the sync engine after it receives the directory change notification on the two attributes. When this flag
		/// is specified, the platform will be allowed to invoke CfDehydratePlaceholder directly on any in-sync cloud file placeholder.
		/// It is recommended for sync providers to support auto-dehydration.
		/// </summary>
		CF_HYDRATION_POLICY_MODIFIER_AUTO_DEHYDRATION_ALLOWED = 4,
	}

	/// <summary>
	/// Allows a sync provider to control how placeholder files should be hydrated by the platform. This is the primary policy.
	/// </summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_hydration_policy_primary typedef enum
	// CF_HYDRATION_POLICY_PRIMARY { CF_HYDRATION_POLICY_PARTIAL, CF_HYDRATION_POLICY_PROGRESSIVE, CF_HYDRATION_POLICY_FULL,
	// CF_HYDRATION_POLICY_ALWAYS_FULL } ;
	[PInvokeData("cfapi.h", MSDNShortId = "47ACA107-80AA-42B3-B583-399323E2B11C")]
	public enum CF_HYDRATION_POLICY_PRIMARY : ushort
	{
		/// <summary>
		/// The same behavior as CF_HYDRATION_POLICY_PROGRESSIVE, except that CF_HYDRATION_POLICY_PARTIAL does not have continuous
		/// hydration in the background.
		/// </summary>
		CF_HYDRATION_POLICY_PARTIAL,

		/// <summary>
		/// When CF_HYDRATION_POLICY_PROGRESSIVE is selected, the platform will allow a placeholder to be dehydrated. When the platform
		/// detects access to a dehydrated placeholder, it will complete the user IO request as soon as it determines that sufficient
		/// data is received from the sync provider. However, the platform will continue requesting the remaining content in the
		/// placeholder from the sync provider in the background until either the full content of the placeholder is available locally,
		/// or the last user handle on the placeholder is closed.
		/// </summary>
		CF_HYDRATION_POLICY_PROGRESSIVE,

		/// <summary>
		/// When CF_HYDRATION_POLICY_FULL is selected, the platform will allow a placeholder to be dehydrated. When the platform detects
		/// access to a dehydrated placeholder, it will ensure that the full content of the placeholder is available locally before
		/// completing the user IO request, even if the request is only asking for 1 byte.
		/// </summary>
		CF_HYDRATION_POLICY_FULL,

		/// <summary>
		/// When CF_HYDRATION_POLICY_ALWAYS_FULL is selected, the platform will block any placeholder operation that could result in a
		/// not fully hydrated placeholder, which includes CfCreatePlaceholders, CfUpdatePlaceholder with the dehydrate option, and
		/// CfConvertToPlaceholder with the dehydrate option.
		/// </summary>
		CF_HYDRATION_POLICY_ALWAYS_FULL,
	}

	/// <summary>Specifies the in-sync state for placeholder files and folders.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_in_sync_state typedef enum CF_IN_SYNC_STATE {
	// CF_IN_SYNC_STATE_NOT_IN_SYNC, CF_IN_SYNC_STATE_IN_SYNC } ;
	[PInvokeData("cfapi.h", MSDNShortId = "05F99E47-00EE-422C-BDDF-CCCDDD4DADED")]
	public enum CF_IN_SYNC_STATE
	{
		/// <summary>The platform clears the placeholder’s in-sync state upon a successful return from the CfSetInSyncState call.</summary>
		CF_IN_SYNC_STATE_NOT_IN_SYNC,

		/// <summary>The platform sets the placeholder’s in-sync state upon a successful return from the CfSetInSyncState call.</summary>
		CF_IN_SYNC_STATE_IN_SYNC,
	}

	/// <summary>
	/// A policy allowing a sync provider to control when the platform should clear the in-sync state on a placeholder file or directory.
	/// </summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_insync_policy typedef enum CF_INSYNC_POLICY {
	// CF_INSYNC_POLICY_NONE, CF_INSYNC_POLICY_TRACK_FILE_CREATION_TIME, CF_INSYNC_POLICY_TRACK_FILE_READONLY_ATTRIBUTE,
	// CF_INSYNC_POLICY_TRACK_FILE_HIDDEN_ATTRIBUTE, CF_INSYNC_POLICY_TRACK_FILE_SYSTEM_ATTRIBUTE,
	// CF_INSYNC_POLICY_TRACK_DIRECTORY_CREATION_TIME, CF_INSYNC_POLICY_TRACK_DIRECTORY_READONLY_ATTRIBUTE,
	// CF_INSYNC_POLICY_TRACK_DIRECTORY_HIDDEN_ATTRIBUTE, CF_INSYNC_POLICY_TRACK_DIRECTORY_SYSTEM_ATTRIBUTE,
	// CF_INSYNC_POLICY_TRACK_FILE_LAST_WRITE_TIME, CF_INSYNC_POLICY_TRACK_DIRECTORY_LAST_WRITE_TIME, CF_INSYNC_POLICY_TRACK_FILE_ALL,
	// CF_INSYNC_POLICY_TRACK_DIRECTORY_ALL, CF_INSYNC_POLICY_TRACK_ALL, CF_INSYNC_POLICY_PRESERVE_INSYNC_FOR_SYNC_ENGINE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "BE9574D7-2717-42F6-AB59-096AACCD8BC1")]
	[Flags]
	public enum CF_INSYNC_POLICY : uint
	{
		/// <summary/>
		CF_INSYNC_POLICY_NONE = 0x00000000,

		/// <summary>Clears in-sync state when a file is created.</summary>
		CF_INSYNC_POLICY_TRACK_FILE_CREATION_TIME = 0x00000001,

		/// <summary>Clears in-sync state when a file is read-only.</summary>
		CF_INSYNC_POLICY_TRACK_FILE_READONLY_ATTRIBUTE = 0x00000002,

		/// <summary>Clears in-sync state when a file is hidden.</summary>
		CF_INSYNC_POLICY_TRACK_FILE_HIDDEN_ATTRIBUTE = 0x00000004,

		/// <summary/>
		CF_INSYNC_POLICY_TRACK_FILE_SYSTEM_ATTRIBUTE = 0x00000008,

		/// <summary>Clears in-sync state when a directory is created.</summary>
		CF_INSYNC_POLICY_TRACK_DIRECTORY_CREATION_TIME = 0x00000010,

		/// <summary>Clears in-sync state when a directory is read-only.</summary>
		CF_INSYNC_POLICY_TRACK_DIRECTORY_READONLY_ATTRIBUTE = 0x00000020,

		/// <summary>Clears in-sync state when a directory is hidden.</summary>
		CF_INSYNC_POLICY_TRACK_DIRECTORY_HIDDEN_ATTRIBUTE = 0x00000040,

		/// <summary>Clears in-sync state when a directory is a system directory.</summary>
		CF_INSYNC_POLICY_TRACK_DIRECTORY_SYSTEM_ATTRIBUTE = 0x00000080,

		/// <summary>Clears in-sync state based on the last write time to a file.</summary>
		CF_INSYNC_POLICY_TRACK_FILE_LAST_WRITE_TIME = 0x00000100,

		/// <summary>Clears in-sync state based on the last write time to a directory.</summary>
		CF_INSYNC_POLICY_TRACK_DIRECTORY_LAST_WRITE_TIME = 0x00000200,

		/// <summary>Clears in-sync state for any changes to a file.</summary>
		CF_INSYNC_POLICY_TRACK_FILE_ALL = 0x0055550f,

		/// <summary>Clears in-sync state for any changes to a directory.</summary>
		CF_INSYNC_POLICY_TRACK_DIRECTORY_ALL = 0x00aaaaf0,

		/// <summary>Clears in-sync state for any changes to a file or directory.</summary>
		CF_INSYNC_POLICY_TRACK_ALL = 0x00ffffff,

		/// <summary>In-sync policies are exempt from clearing.</summary>
		CF_INSYNC_POLICY_PRESERVE_INSYNC_FOR_SYNC_ENGINE = 0x80000000,
	}

	/// <summary>Flags to request various permissions on opening a file.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_open_file_flags typedef enum CF_OPEN_FILE_FLAGS {
	// CF_OPEN_FILE_FLAG_NONE, CF_OPEN_FILE_FLAG_EXCLUSIVE, CF_OPEN_FILE_FLAG_WRITE_ACCESS, CF_OPEN_FILE_FLAG_DELETE_ACCESS,
	// CF_OPEN_FILE_FLAG_FOREGROUND } ;
	[PInvokeData("cfapi.h", MSDNShortId = "4A9D87AB-7B81-46DF-80C3-DB2F63C76964")]
	[Flags]
	public enum CF_OPEN_FILE_FLAGS
	{
		/// <summary>No open file flags.</summary>
		CF_OPEN_FILE_FLAG_NONE = 0,

		/// <summary>When specified, CfOpenFileWithOplock returns a share-none handle and requests an RH (OPLOCK_LEVEL_CACHE_READ</summary>
		CF_OPEN_FILE_FLAG_EXCLUSIVE = 1,

		/// <summary>
		/// When specified, CfOpenFileWithOplock attempts to open the file or directory with FILE_READ_DATA/FILE_LIST_DIRECTORY and
		/// FILE_WRITE_DATA/FILE_ADD_FILE access; otherwise it attempts to open the file or directory with FILE_READ_DATA/ FILE_LIST_DIRECTORY.
		/// </summary>
		CF_OPEN_FILE_FLAG_WRITE_ACCESS = 2,

		/// <summary>
		/// When specified, CfOpenFileWithOplock attempts to open the file or directory with DELETE access; otherwise it opens the file normally.
		/// </summary>
		CF_OPEN_FILE_FLAG_DELETE_ACCESS = 4,

		/// <summary/>
		CF_OPEN_FILE_FLAG_FOREGROUND = 8,
	}

	/// <summary>Flags to verify and acknowledge data for a placeholder file or folder.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_ack_data_flags typedef enum
	// CF_OPERATION_ACK_DATA_FLAGS { CF_OPERATION_ACK_DATA_FLAG_NONE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "9465B686-7C8A-44AD-BC65-41F22FFEC741")]
	[Flags]
	public enum CF_OPERATION_ACK_DATA_FLAGS
	{
		/// <summary>No acknowledge data flag.</summary>
		CF_OPERATION_ACK_DATA_FLAG_NONE = 0,
	}

	/// <summary>Flags to acknowledge the dehydration of a placeholder file or directory.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_ack_dehydrate_flags typedef enum
	// CF_OPERATION_ACK_DEHYDRATE_FLAGS { CF_OPERATION_ACK_DEHYDRATE_FLAG_NONE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "A1236139-947A-4360-91A0-E634A22C26A5")]
	[Flags]
	public enum CF_OPERATION_ACK_DEHYDRATE_FLAGS
	{
		/// <summary>No acknowledge dehydration flag.</summary>
		CF_OPERATION_ACK_DEHYDRATE_FLAG_NONE = 0,
	}

	/// <summary>Flags to acknowledge the deletion of a placeholder file or directory.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_ack_delete_flags typedef enum
	// CF_OPERATION_ACK_DELETE_FLAGS { CF_OPERATION_ACK_DELETE_FLAG_NONE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "407B7035-09A0-43BC-AC07-2CC0973DDBCC")]
	[Flags]
	public enum CF_OPERATION_ACK_DELETE_FLAGS
	{
		/// <summary>No deletion acknowledgment flags.</summary>
		CF_OPERATION_ACK_DELETE_FLAG_NONE = 0,
	}

	/// <summary>Flags for acknowledging placeholder file or directory renaming.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_ack_rename_flags typedef enum
	// CF_OPERATION_ACK_RENAME_FLAGS { CF_OPERATION_ACK_RENAME_FLAG_NONE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "2EAABBAE-8737-4399-8C39-7D63B45C52B3")]
	[Flags]
	public enum CF_OPERATION_ACK_RENAME_FLAGS
	{
		/// <summary>No acknowledgment of placeholder renaming.</summary>
		CF_OPERATION_ACK_RENAME_FLAG_NONE = 0,
	}

	/// <summary>Flags to restart data hydration on a placeholder file or folder.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_restart_hydration_flags typedef enum
	// CF_OPERATION_RESTART_HYDRATION_FLAGS { CF_OPERATION_RESTART_HYDRATION_FLAG_NONE, CF_OPERATION_RESTART_HYDRATION_FLAG_MARK_IN_SYNC
	// } ;
	[PInvokeData("cfapi.h", MSDNShortId = "4112937A-3ED6-48F8-BFD1-52D01ABA3D72")]
	[Flags]
	public enum CF_OPERATION_RESTART_HYDRATION_FLAGS
	{
		/// <summary>No restart data hydration flag.</summary>
		CF_OPERATION_RESTART_HYDRATION_FLAG_NONE = 0,

		/// <summary>If this flag is specified, the placeholder will be marked in-sync upon a successful RESTART_HYDRATION operation.</summary>
		CF_OPERATION_RESTART_HYDRATION_FLAG_MARK_IN_SYNC = 1,
	}

	/// <summary>Flags to retrieve data for a placeholder file or folder.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_retrieve_data_flags typedef enum
	// CF_OPERATION_RETRIEVE_DATA_FLAGS { CF_OPERATION_RETRIEVE_DATA_FLAG_NONE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "A233B2E8-B350-495A-9688-3795790F23EF")]
	[Flags]
	public enum CF_OPERATION_RETRIEVE_DATA_FLAGS
	{
		/// <summary>No retrieve data flag.</summary>
		CF_OPERATION_RETRIEVE_DATA_FLAG_NONE = 0,
	}

	/// <summary>Flags to transfer data to hydrate a placeholder file or folder.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_transfer_data_flags typedef enum
	// CF_OPERATION_TRANSFER_DATA_FLAGS { CF_OPERATION_TRANSFER_DATA_FLAG_NONE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "6273CB7A-80B9-4E9A-8C3A-5308F59BB335")]
	[Flags]
	public enum CF_OPERATION_TRANSFER_DATA_FLAGS
	{
		/// <summary>No transfer data flag.</summary>
		CF_OPERATION_TRANSFER_DATA_FLAG_NONE = 0,
	}

	/// <summary>Flags to specify the behavior when transferring a placeholder file or directory.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_transfer_placeholders_flags typedef enum
	// CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAGS { CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAG_NONE,
	// CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAG_STOP_ON_ERROR, CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAG_DISABLE_ON_DEMAND_POPULATION } ;
	[PInvokeData("cfapi.h", MSDNShortId = "6C75030D-A5CF-423D-A931-3D2ED6113BD1")]
	[Flags]
	public enum CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAGS
	{
		/// <summary>No transfer placeholder flags.</summary>
		CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAG_NONE = 0,

		/// <summary>
		/// Causes the API to return immediately if a placeholder transfer fails. If a transfer fails, the error code will be returned.
		/// </summary>
		CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAG_STOP_ON_ERROR = 1,

		/// <summary>
		/// The transferred child placeholder directory is considered to have all of its children present locally.Applicable to a child
		/// placeholder directory only.
		/// </summary>
		CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAG_DISABLE_ON_DEMAND_POPULATION = 2,
	}

	/// <summary>The types of operations that can be performed on placeholder files and directories.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_type typedef enum CF_OPERATION_TYPE {
	// CF_OPERATION_TYPE_TRANSFER_DATA, CF_OPERATION_TYPE_RETRIEVE_DATA, CF_OPERATION_TYPE_ACK_DATA,
	// CF_OPERATION_TYPE_RESTART_HYDRATION, CF_OPERATION_TYPE_TRANSFER_PLACEHOLDERS, CF_OPERATION_TYPE_ACK_DEHYDRATE,
	// CF_OPERATION_TYPE_ACK_DELETE, CF_OPERATION_TYPE_ACK_RENAME } ;
	[PInvokeData("cfapi.h", MSDNShortId = "34E23442-1BCC-4B8B-9AD3-67B2AEDBE2FE")]
	public enum CF_OPERATION_TYPE
	{
		/// <summary>Transfers data to hydrate a placeholder.</summary>
		CF_OPERATION_TYPE_TRANSFER_DATA,

		/// <summary>Validates the integrity of data previously transferred to a placeholder.</summary>
		CF_OPERATION_TYPE_RETRIEVE_DATA,

		/// <summary>Data is acknowledged by the sync provider.</summary>
		CF_OPERATION_TYPE_ACK_DATA,

		/// <summary>Restarts ongoing data hydration.</summary>
		CF_OPERATION_TYPE_RESTART_HYDRATION,

		/// <summary>Transfers placeholders.</summary>
		CF_OPERATION_TYPE_TRANSFER_PLACEHOLDERS,

		/// <summary>Acknowledge and dehydrate a placeholder.</summary>
		CF_OPERATION_TYPE_ACK_DEHYDRATE,

		/// <summary>Acknowledge and delete a placeholder.</summary>
		CF_OPERATION_TYPE_ACK_DELETE,

		/// <summary>Acknowledge and rename a placeholder.</summary>
		CF_OPERATION_TYPE_ACK_RENAME,
	}

	/// <summary>Pin states of a placeholder file or directory.</summary>
	/// <remarks>
	/// <list type="table">
	/// <listheader>
	/// <term/>
	/// <term>Parent</term>
	/// <term>Unspecified</term>
	/// <term>Pinned</term>
	/// <term>Unpinned</term>
	/// <term>Excluded</term>
	/// </listheader>
	/// <item>
	/// <term>File</term>
	/// <term>Unspecified</term>
	/// <term>Unspecified</term>
	/// <term>Pinned</term>
	/// <term>Unspecified</term>
	/// <term>Excluded</term>
	/// </item>
	/// <item>
	/// <term/>
	/// <term>Pinned</term>
	/// <term>Pinned</term>
	/// <term>Pinned</term>
	/// <term>Pinned</term>
	/// <term>Excluded</term>
	/// </item>
	/// <item>
	/// <term/>
	/// <term>Unpinned</term>
	/// <term>Unpinned</term>
	/// <term>Unpinned</term>
	/// <term>Unpinned</term>
	/// <term>Excluded</term>
	/// </item>
	/// <item>
	/// <term/>
	/// <term>Excluded</term>
	/// <term>Unspecified</term>
	/// <term>Pinned</term>
	/// <term>Unspecified</term>
	/// <term>Excluded</term>
	/// </item>
	/// <item>
	/// <term>Directory</term>
	/// <term>Unspecified</term>
	/// <term>Unspecified</term>
	/// <term>Pinned</term>
	/// <term>Unpinned</term>
	/// <term>Excluded</term>
	/// </item>
	/// <item>
	/// <term/>
	/// <term>Pinned</term>
	/// <term>Pinned</term>
	/// <term>Pinned</term>
	/// <term>Pinned</term>
	/// <term>Excluded</term>
	/// </item>
	/// <item>
	/// <term/>
	/// <term>Unpinned</term>
	/// <term>Unpinned</term>
	/// <term>Unpinned</term>
	/// <term>Unpinned</term>
	/// <term>Excluded</term>
	/// </item>
	/// <item>
	/// <term/>
	/// <term>Excluded</term>
	/// <term>Unspecified</term>
	/// <term>Pinned</term>
	/// <term>Unpinned</term>
	/// <term>Excluded</term>
	/// </item>
	/// </list>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_pin_state typedef enum CF_PIN_STATE {
	// CF_PIN_STATE_UNSPECIFIED, CF_PIN_STATE_PINNED, CF_PIN_STATE_UNPINNED, CF_PIN_STATE_EXCLUDED, CF_PIN_STATE_INHERIT } ;
	[PInvokeData("cfapi.h", MSDNShortId = "F3074C9A-2805-47DE-9BA0-D7E02C4FF030")]
	public enum CF_PIN_STATE
	{
		/// <summary>The platform can decide freely when the placeholder’s content needs to present or absent locally on the disk.</summary>
		CF_PIN_STATE_UNSPECIFIED,

		/// <summary>
		/// The sync provider will be notified to fetch the placeholder’s content asynchronously after the pin request is received by
		/// the platform. There is no guarantee that the placeholders to be pinned will be fully available locally after a CfSetPinState
		/// call completes successfully. However, the platform will fail any dehydration request on pinned placeholders.
		/// </summary>
		CF_PIN_STATE_PINNED,

		/// <summary>
		/// The sync provider will be notified to dehydrate/invalidate the placeholder’s content on-disk asynchronously after the unpin
		/// request is received by the platform. There is no guarantee that the placeholders to be unpinned will be fully dehydrated
		/// after the API call completes successfully.
		/// </summary>
		CF_PIN_STATE_UNPINNED,

		/// <summary>
		/// the placeholder will never be synced to the cloud by the sync provider. This state can only be set by the sync provider.
		/// </summary>
		CF_PIN_STATE_EXCLUDED,

		/// <summary>
		/// The platform treats it as if the caller performs a move operation on the placeholder and hence re-evaluates the
		/// placeholder’s pin state based on its parent’s pin state. See the Remarks section for an inheritance table.
		/// </summary>
		CF_PIN_STATE_INHERIT,
	}

	/// <summary>Flags for creating a placeholder on a per-placeholder basis.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_placeholder_create_flags typedef enum
	// CF_PLACEHOLDER_CREATE_FLAGS { CF_PLACEHOLDER_CREATE_FLAG_NONE, CF_PLACEHOLDER_CREATE_FLAG_DISABLE_ON_DEMAND_POPULATION,
	// CF_PLACEHOLDER_CREATE_FLAG_MARK_IN_SYNC, CF_PLACEHOLDER_CREATE_FLAG_SUPERSEDE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "7DB55949-E209-490C-9FF9-53E1D72CD0FA")]
	[Flags]
	public enum CF_PLACEHOLDER_CREATE_FLAGS
	{
		/// <summary>No placeholder create flags.</summary>
		CF_PLACEHOLDER_CREATE_FLAG_NONE = 0,

		/// <summary>
		/// The newly created child placeholder directory is considered to have all of its children present locally. Applicable to a
		/// child placeholder directory only.
		/// </summary>
		CF_PLACEHOLDER_CREATE_FLAG_DISABLE_ON_DEMAND_POPULATION = 1,

		/// <summary>The newly created placeholder is marked as in-sync. Applicable to both placeholder files and directories.</summary>
		CF_PLACEHOLDER_CREATE_FLAG_MARK_IN_SYNC = 2,

		/// <summary/>
		CF_PLACEHOLDER_CREATE_FLAG_SUPERSEDE = 4,
	}

	/// <summary>Information classes for placeholder info.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_placeholder_info_class typedef enum
	// CF_PLACEHOLDER_INFO_CLASS { CF_PLACEHOLDER_INFO_BASIC, CF_PLACEHOLDER_INFO_STANDARD } ;
	[PInvokeData("cfapi.h", MSDNShortId = "DA05148F-3EF0-4CC3-9233-883859FA00F1")]
	public enum CF_PLACEHOLDER_INFO_CLASS
	{
		/// <summary>Basic placeholder information. See CF_PLACEHOLDER_BASIC_INFO.</summary>
		[CorrespondingType(typeof(CF_PLACEHOLDER_BASIC_INFO), CorrespondingAction.Get)]
		CF_PLACEHOLDER_INFO_BASIC,

		/// <summary>Standard placeholder information. See CF_PLACEHOLDER_STANDARD_INFO.</summary>
		[CorrespondingType(typeof(CF_PLACEHOLDER_STANDARD_INFO), CorrespondingAction.Get)]
		CF_PLACEHOLDER_INFO_STANDARD,
	}

	/// <summary>Types of the range of placeholder file data.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_placeholder_range_info_class typedef enum
	// CF_PLACEHOLDER_RANGE_INFO_CLASS { CF_PLACEHOLDER_RANGE_INFO_ONDISK, CF_PLACEHOLDER_RANGE_INFO_VALIDATED,
	// CF_PLACEHOLDER_RANGE_INFO_MODIFIED } ;
	[PInvokeData("cfapi.h", MSDNShortId = "04533C98-894C-422F-9BE5-F2746BF13567")]
	public enum CF_PLACEHOLDER_RANGE_INFO_CLASS
	{
		/// <summary>On-disk data is data that is physical present in the file, which is a super set of other types of ranges.</summary>
		CF_PLACEHOLDER_RANGE_INFO_ONDISK = 1,

		/// <summary>Validated data is a subset of the on-disk data that is currently in sync with the cloud.</summary>
		CF_PLACEHOLDER_RANGE_INFO_VALIDATED,

		/// <summary>
		/// Modified data is a subset of the on-disk data that is currently not in sync with the cloud, i.e., either modified or appended.
		/// </summary>
		CF_PLACEHOLDER_RANGE_INFO_MODIFIED,
	}

	/// <summary>The state of a placeholder file or folder.</summary>
	/// <remarks>
	/// Placeholder state information can be obtained by calling: CfGetPlaceholderStateFromAttributeTag,
	/// CfGetPlaceholderStateFromFileInfo, or CfGetPlaceholderStateFromFindData.
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_placeholder_state typedef enum CF_PLACEHOLDER_STATE {
	// CF_PLACEHOLDER_STATE_NO_STATES, CF_PLACEHOLDER_STATE_PLACEHOLDER, CF_PLACEHOLDER_STATE_SYNC_ROOT,
	// CF_PLACEHOLDER_STATE_ESSENTIAL_PROP_PRESENT, CF_PLACEHOLDER_STATE_IN_SYNC, CF_PLACEHOLDER_STATE_PARTIAL,
	// CF_PLACEHOLDER_STATE_PARTIALLY_ON_DISK, CF_PLACEHOLDER_STATE_INVALID } ;
	[PInvokeData("cfapi.h", MSDNShortId = "5E814458-2045-4CFD-90AC-F1F53DEB4FD0")]
	[Flags]
	public enum CF_PLACEHOLDER_STATE : uint
	{
		/// <summary>When returned, the file or directory whose FileAttributes and ReparseTag examined by the API is not a placeholder.</summary>
		CF_PLACEHOLDER_STATE_NO_STATES = 0x00000000,

		/// <summary>The file or directory whose FileAttributes and ReparseTag examined by the API is a placeholder.</summary>
		CF_PLACEHOLDER_STATE_PLACEHOLDER = 0x00000001,

		/// <summary>The directory is both a placeholder directory as well as the sync root.</summary>
		CF_PLACEHOLDER_STATE_SYNC_ROOT = 0x00000002,

		/// <summary>
		/// The file or directory must be a placeholder and there exists an essential property in the property store of the file or directory.
		/// </summary>
		CF_PLACEHOLDER_STATE_ESSENTIAL_PROP_PRESENT = 0x00000004,

		/// <summary>The file or directory must be a placeholder and its content in sync with the cloud.</summary>
		CF_PLACEHOLDER_STATE_IN_SYNC = 0x00000008,

		/// <summary>
		/// The file or directory must be a placeholder and its content is not ready to be consumed by the user application, though it
		/// may or may not be fully present locally. An example is a placeholder file whose content has been fully downloaded to the
		/// local disk, but is yet to be validated by a sync provider that has registered the sync root with the hydration modifier VERIFICATION_REQUIRED.
		/// </summary>
		CF_PLACEHOLDER_STATE_PARTIAL = 0x00000010,

		/// <summary>
		/// The file or directory must be a placeholder and its content is not fully present locally. When this is set,
		/// CF_PLACEHOLDER_STATE_PARTIAL must also be set.
		/// </summary>
		CF_PLACEHOLDER_STATE_PARTIALLY_ON_DISK = 0x00000020,

		/// <summary>This is an invalid state when the API fails to parse the information of the file or directory.</summary>
		CF_PLACEHOLDER_STATE_INVALID = 0xffffffff,
	}

	/// <summary>Defines the population policy modifiers. This is a modifier that can be used with the primary policy: CF_POPULATION_POLICY_PRIMARY.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_population_policy_modifier typedef enum
	// CF_POPULATION_POLICY_MODIFIER { CF_POPULATION_POLICY_MODIFIER_NONE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "E8F8066C-BAAE-4576-BA8F-49074F7C3C8F")]
	[Flags]
	public enum CF_POPULATION_POLICY_MODIFIER : ushort
	{
		/// <summary>No policy modifier.</summary>
		CF_POPULATION_POLICY_MODIFIER_NONE = 0,
	}

	/// <summary>
	/// Allows a sync provider to control how placeholder directories and files should be created by the platform. This is the primary policy.
	/// </summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_population_policy_primary typedef enum
	// CF_POPULATION_POLICY_PRIMARY { CF_POPULATION_POLICY_PARTIAL, CF_POPULATION_POLICY_FULL, CF_POPULATION_POLICY_ALWAYS_FULL } ;
	[PInvokeData("cfapi.h", MSDNShortId = "3EDCDE3D-AD47-4C4B-9F83-C89879D668DA")]
	public enum CF_POPULATION_POLICY_PRIMARY : ushort
	{
		/// <summary>
		/// With CF_POPULATION_POLICY_PARTIAL population policy, when the platform detects access on a not fully populated directory, it
		/// will request only the entries required by the user application from the sync provider. This policy is not currently
		/// supported by the platform.
		/// </summary>
		CF_POPULATION_POLICY_PARTIAL = 0,

		/// <summary>
		/// With CF_POPULATION_POLICY_FULL population policy, when the platform detects access on a not fully populated directory, it
		/// will request the sync provider return all entries under the directory before completing the user request.
		/// </summary>
		CF_POPULATION_POLICY_FULL = 2,

		/// <summary>
		/// When CF_POPULATION_POLICY_ALWAYS_FULL is selected, the platform assumes that the full name space is always available
		/// locally. It will never forward any directory enumeration request to the sync provider.
		/// </summary>
		CF_POPULATION_POLICY_ALWAYS_FULL = 3,
	}

	/// <summary>Flags for registering and updating a sync root.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_register_flags typedef enum CF_REGISTER_FLAGS {
	// CF_REGISTER_FLAG_NONE, CF_REGISTER_FLAG_UPDATE, CF_REGISTER_FLAG_DISABLE_ON_DEMAND_POPULATION_ON_ROOT,
	// CF_REGISTER_FLAG_MARK_IN_SYNC_ON_ROOT } ;
	[PInvokeData("cfapi.h", MSDNShortId = "043670D7-5908-40B5-82A8-EFF05FCB391B")]
	[Flags]
	public enum CF_REGISTER_FLAGS
	{
		/// <summary>No registration flags.</summary>
		CF_REGISTER_FLAG_NONE = 0,

		/// <summary>Use this flag for modifying previously registered sync root identities and policies.</summary>
		CF_REGISTER_FLAG_UPDATE = 1,

		/// <summary>
		/// The on-demand directory/folder population behavior is globally controlled by the population policy. This flag allows a sync
		/// provider to opt out of the on-demand population behavior just for the sync root itself while keeping on-demand population on
		/// for all other directories under the sync root. This is useful when the sync provider would like to pre-populate the
		/// immediate child files/directories of the sync root.
		/// </summary>
		CF_REGISTER_FLAG_DISABLE_ON_DEMAND_POPULATION_ON_ROOT = 2,

		/// <summary>
		/// This flag allows a sync provider to mark the sync root to be registered in-sync simultaneously at the registration time. An
		/// alternative is to call CfSetInSyncState on the sync root later.
		/// </summary>
		CF_REGISTER_FLAG_MARK_IN_SYNC_ON_ROOT = 4,
	}

	/// <summary>Flags for reverting a placeholder file to a regular file.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_revert_flags typedef enum CF_REVERT_FLAGS {
	// CF_REVERT_FLAG_NONE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "71FDE7FA-99FC-4773-A857-8E1BF89ED7E4")]
	[Flags]
	public enum CF_REVERT_FLAGS
	{
		/// <summary>No placeholder revert flags.</summary>
		CF_REVERT_FLAG_NONE = 0,
	}

	/// <summary>The in-sync state flags for placeholder files and folders.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_set_in_sync_flags typedef enum CF_SET_IN_SYNC_FLAGS {
	// CF_SET_IN_SYNC_FLAG_NONE } ;
	[PInvokeData("cfapi.h", MSDNShortId = "55A20F07-0B3E-4C1D-9E59-288DAE08D134")]
	[Flags]
	public enum CF_SET_IN_SYNC_FLAGS
	{
		/// <summary>No in-sync flag.</summary>
		CF_SET_IN_SYNC_FLAG_NONE = 0,
	}

	/// <summary>The placeholder pin flags.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_set_pin_flags typedef enum CF_SET_PIN_FLAGS {
	// CF_SET_PIN_FLAG_NONE, CF_SET_PIN_FLAG_RECURSE, CF_SET_PIN_FLAG_RECURSE_ONLY, CF_SET_PIN_FLAG_RECURSE_STOP_ON_ERROR } ;
	[PInvokeData("cfapi.h", MSDNShortId = "6766931E-B2D4-4166-9B6E-E6D8F57E57B3")]
	[Flags]
	public enum CF_SET_PIN_FLAGS
	{
		/// <summary>No pin flag.</summary>
		CF_SET_PIN_FLAG_NONE = 0,

		/// <summary>
		/// The platform applies the pin state to the placeholder FileHandle and every file recursively beneath it (relevant only if
		/// FileHandle is a handle to a directory).
		/// </summary>
		CF_SET_PIN_FLAG_RECURSE = 1,

		/// <summary>
		/// The platform applies the pin state to every file recursively beneath the placeholder FileHandle, but not to FileHandle itself.
		/// </summary>
		CF_SET_PIN_FLAG_RECURSE_ONLY = 2,

		/// <summary>
		/// The platform will stop the recursion when encountering the first error; otherwise the platform skips the error and continues
		/// the recursion.
		/// </summary>
		CF_SET_PIN_FLAG_RECURSE_STOP_ON_ERROR = 4,
	}

	/// <summary>Current status of a sync provider.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_sync_provider_status typedef enum CF_SYNC_PROVIDER_STATUS {
	// CF_PROVIDER_STATUS_DISCONNECTED, CF_PROVIDER_STATUS_IDLE, CF_PROVIDER_STATUS_POPULATE_NAMESPACE,
	// CF_PROVIDER_STATUS_POPULATE_METADATA, CF_PROVIDER_STATUS_POPULATE_CONTENT, CF_PROVIDER_STATUS_SYNC_INCREMENTAL,
	// CF_PROVIDER_STATUS_SYNC_FULL, CF_PROVIDER_STATUS_CONNECTIVITY_LOST, CF_PROVIDER_STATUS_CLEAR_FLAGS,
	// CF_PROVIDER_STATUS_TERMINATED, CF_PROVIDER_STATUS_ERROR } ;
	[PInvokeData("cfapi.h", MSDNShortId = "575A9F66-66D4-4443-9BCB-0CBD60DA27A0")]
	[Flags]
	public enum CF_SYNC_PROVIDER_STATUS : uint
	{
		/// <summary>The sync provider is disconnected.</summary>
		CF_PROVIDER_STATUS_DISCONNECTED = 0x00000000,

		/// <summary>The sync provider is idle.</summary>
		CF_PROVIDER_STATUS_IDLE = 0x00000001,

		/// <summary>The sync provider is populating a namespace.</summary>
		CF_PROVIDER_STATUS_POPULATE_NAMESPACE = 0x00000002,

		/// <summary>The sync provider is populating placeholder metadata.</summary>
		CF_PROVIDER_STATUS_POPULATE_METADATA = 0x00000004,

		/// <summary>The sync provider is populating placeholder content.</summary>
		CF_PROVIDER_STATUS_POPULATE_CONTENT = 0x00000008,

		/// <summary>The sync provider is incrementally syncing placeholder content.</summary>
		CF_PROVIDER_STATUS_SYNC_INCREMENTAL = 0x00000010,

		/// <summary>The sync provider has fully synced placeholder file data.</summary>
		CF_PROVIDER_STATUS_SYNC_FULL = 0x00000020,

		/// <summary>The sync provider has lost connectivity.</summary>
		CF_PROVIDER_STATUS_CONNECTIVITY_LOST = 0x00000040,

		/// <summary>Clears the flags of the sync provider.</summary>
		CF_PROVIDER_STATUS_CLEAR_FLAGS = 0x80000000,

		/// <summary/>
		CF_PROVIDER_STATUS_TERMINATED = 0xC0000001,

		/// <summary/>
		CF_PROVIDER_STATUS_ERROR = 0xC0000002,
	}

	/// <summary>Types of sync root information.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_sync_root_info_class typedef enum CF_SYNC_ROOT_INFO_CLASS {
	// CF_SYNC_ROOT_INFO_BASIC, CF_SYNC_ROOT_INFO_STANDARD, CF_SYNC_ROOT_INFO_PROVIDER } ;
	[PInvokeData("cfapi.h", MSDNShortId = "4415E075-048E-4B9F-B293-5F7A63CAE3A4")]
	public enum CF_SYNC_ROOT_INFO_CLASS
	{
		/// <summary>Basic sync root information. See CF_SYNC_ROOT_BASIC_INFO.</summary>
		[CorrespondingType(typeof(CF_SYNC_ROOT_BASIC_INFO), CorrespondingAction.Get)]
		CF_SYNC_ROOT_INFO_BASIC,

		/// <summary>Standard sync root information. See CF_SYNC_ROOT_STANDARD_INFO.</summary>
		[CorrespondingType(typeof(CF_SYNC_ROOT_STANDARD_INFO), CorrespondingAction.Get)]
		CF_SYNC_ROOT_INFO_STANDARD,

		/// <summary>Sync root provider information. See CF_SYNC_ROOT_PROVIDER_INFO.</summary>
		[CorrespondingType(typeof(CF_SYNC_ROOT_PROVIDER_INFO), CorrespondingAction.Get)]
		CF_SYNC_ROOT_INFO_PROVIDER,
	}

	/// <summary>Flags for updating a placeholder file or directory.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_update_flags typedef enum CF_UPDATE_FLAGS {
	// CF_UPDATE_FLAG_NONE, CF_UPDATE_FLAG_VERIFY_IN_SYNC, CF_UPDATE_FLAG_MARK_IN_SYNC, CF_UPDATE_FLAG_DEHYDRATE,
	// CF_UPDATE_FLAG_ENABLE_ON_DEMAND_POPULATION, CF_UPDATE_FLAG_DISABLE_ON_DEMAND_POPULATION, CF_UPDATE_FLAG_REMOVE_FILE_IDENTITY,
	// CF_UPDATE_FLAG_CLEAR_IN_SYNC, CF_UPDATE_FLAG_REMOVE_PROPERTY, CF_UPDATE_FLAG_PASSTHROUGH_FS_METADATA } ;
	[PInvokeData("cfapi.h", MSDNShortId = "83EBEF22-9EAE-4B51-AA23-325FA96EB070")]
	[Flags]
	public enum CF_UPDATE_FLAGS : uint
	{
		/// <summary>No update flags.</summary>
		CF_UPDATE_FLAG_NONE = 0x00000000,

		/// <summary>
		/// The update will fail if the CF_UPDATE_FLAG_MARK_IN_SYNC attribute is not currently set on the placeholder. This is to
		/// prevent a race between syncing changes from the cloud down to a local placeholder and the placeholder’s data stream getting
		/// locally modified.
		/// </summary>
		CF_UPDATE_FLAG_VERIFY_IN_SYNC = 0x00000001,

		/// <summary>The platform marks the placeholder as in-sync upon a successful update placeholder operation.</summary>
		CF_UPDATE_FLAG_MARK_IN_SYNC = 0x00000002,

		/// <summary>
		/// Applicable to files only. When specified, the platform dehydrates the file after updating the placeholder successfully. The
		/// caller must acquire an exclusive handle when specifying this flag or data corruptions can occur. Note that the platform does
		/// not validate the exclusiveness of the handle.
		/// </summary>
		CF_UPDATE_FLAG_DEHYDRATE = 0x00000004,

		/// <summary>
		/// Applicable to directories only. When specified, it marks the updated placeholder directory partially populated such that any
		/// future access to it will result in a FETCH_PLACEHOLDERS callback sent to the sync provider.
		/// </summary>
		CF_UPDATE_FLAG_ENABLE_ON_DEMAND_POPULATION = 0x00000008,

		/// <summary>
		/// Applicable to directories only. When specified, it marks the updated placeholder directory fully populated such that any
		/// future access to it will be handled by the platform without any callbacks to the sync provider.
		/// </summary>
		CF_UPDATE_FLAG_DISABLE_ON_DEMAND_POPULATION = 0x00000010,

		/// <summary>
		/// When specified, FileIdentity and FileIdentityLength in CfUpdatePlaceholder are ignored and the platform will remove the
		/// existing file identity blob on the placeholder upon a successful update call.
		/// </summary>
		CF_UPDATE_FLAG_REMOVE_FILE_IDENTITY = 0x00000020,

		/// <summary>The platform marks the placeholder as not in-sync upon a successful update placeholder operation.</summary>
		CF_UPDATE_FLAG_CLEAR_IN_SYNC = 0x00000040,

		/// <summary>
		/// Note This value is new for Windows 10, version 1803.The platform removes all existing extrinsic properties on the placeholder.
		/// </summary>
		CF_UPDATE_FLAG_REMOVE_PROPERTY = 0x00000080,

		/// <summary>
		/// Note This value is new for Windows 10, version 1803.The platform passes CF_FS_METADATA to the file system without any
		/// filtering; otherwise, the platform skips setting any fields whose value is 0.
		/// </summary>
		CF_UPDATE_FLAG_PASSTHROUGH_FS_METADATA = 0x00000100,

		/// <summary>
		/// Effective on placeholder files only. Marks the placeholder always full.  
		/// Once hydrated, any attempt to dehydrate will fail with
		/// ERROR_CLOUD_FILE_DEHYDRATION_DISALLOWED.
		/// </summary>
		CF_UPDATE_FLAG_ALWAYS_FULL = 0x00000200,

		/// <summary>
		/// Effective on placeholder files only. Clears the always‑full state, allowing
		/// dehydration again. Cannot be combined with CF_UPDATE_FLAG_ALWAYS_FULL; doing
		/// so returns ERROR_CLOUD_FILE_INVALID_REQUEST.
		/// </summary>
		CF_UPDATE_FLAG_ALLOW_PARTIAL = 0x00000400,

	}

	/// <summary>Contains common callback information.</summary>
	/// <remarks>
	/// <para>A file name is considered normalized if all of the following are true:</para>
	/// <list type="bullet">
	/// <item>
	/// <term>
	/// It contains the full directory path for the file, including the volume name, unless the user opened the file by file ID but does
	/// not have traverse privilege for the entire path. (For more information, see FltGetFileNameInformation.)
	/// </term>
	/// </item>
	/// <item>
	/// <term>The volume name is the volume's non-persistent device object name (for example, "\Device\HarddiskVolume1").</term>
	/// </item>
	/// <item>
	/// <term>All short names are expanded to the equivalent long names.</term>
	/// </item>
	/// <item>
	/// <term>Any trailing ":$DATA" or "::$DATA" strings are removed from the stream name.</term>
	/// </item>
	/// <item>
	/// <term>All mount points are resolved.</term>
	/// </item>
	/// </list>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_callback_info typedef struct CF_CALLBACK_INFO { DWORD
	// StructSize; CF_CONNECTION_KEY ConnectionKey; LPVOID CallbackContext; PCWSTR VolumeGuidName; PCWSTR VolumeDosName; DWORD
	// VolumeSerialNumber; LARGE_INTEGER SyncRootFileId; LPCVOID SyncRootIdentity; DWORD SyncRootIdentityLength; LARGE_INTEGER FileId;
	// LARGE_INTEGER FileSize; LPCVOID FileIdentity; DWORD FileIdentityLength; PCWSTR NormalizedPath; CF_TRANSFER_KEY TransferKey; UCHAR
	// PriorityHint; PCORRELATION_VECTOR CorrelationVector; CF_PROCESS_INFO *ProcessInfo; CF_REQUEST_KEY RequestKey; } CF_CALLBACK_INFO;
	[PInvokeData("cfapi.h", MSDNShortId = "EF24E61E-4AF7-4946-A326-1F045267AE01")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_CALLBACK_INFO
	{
		/// <summary>The size of the structure.</summary>
		public uint StructSize;

		/// <summary>An opaque handle created by CfConnectSyncRoot for a sync root managed by the sync provider.</summary>
		public CF_CONNECTION_KEY ConnectionKey;

		/// <summary>points to an opaque blob that the sync provider provides at the sync root connect time.</summary>
		public IntPtr CallbackContext;

		/// <summary>GUID name of the volume on which the placeholder file/directory to be serviced resides. It is in the form: “\?\Volume{GUID}”.</summary>
		[MarshalAs(UnmanagedType.LPWStr)] public string VolumeGuidName;

		/// <summary>DOS drive letter of the volume in the form of “X:” where X is the drive letter.</summary>
		[MarshalAs(UnmanagedType.LPWStr)] public string VolumeDosName;

		/// <summary>The serial number of the volume.</summary>
		public uint VolumeSerialNumber;

		/// <summary>
		/// A 64 bit file system maintained volume-wide unique ID of the sync root under which the placeholder file/directory to be
		/// serviced resides.
		/// </summary>
		public long SyncRootFileId;

		/// <summary>Points to the opaque blob provided by the sync provider at the sync root registration time.</summary>
		public IntPtr SyncRootIdentity;

		/// <summary>The length, in bytes, of the <c>SyncRootIdentity</c>.</summary>
		public uint SyncRootIdentityLength;

		/// <summary>A 64 bit file system maintained, volume-wide unique ID of the placeholder file/directory to be serviced.</summary>
		public long FileId;

		/// <summary>
		/// The logical size of the placeholder file to be serviced. It is always 0 if the subject of the callback is a directory.
		/// </summary>
		public long FileSize;

		/// <summary>Points to the opaque blob that the sync provider provides at the placeholder creation/conversion/update time.</summary>
		public IntPtr FileIdentity;

		/// <summary>The length, in bytes, of <c>FileIdentity</c>.</summary>
		public uint FileIdentityLength;

		/// <summary>
		/// The absolute path of the placeholder file/directory to be serviced on the volume identified by VolumeGuidName/VolumeDosName.
		/// It starts from the root directory of the volume. See the Remarks section for more details.
		/// </summary>
		[MarshalAs(UnmanagedType.LPWStr)] public string NormalizedPath;

		/// <summary>
		/// An opaque handle to the placeholder file/directory to be serviced. The sync provider must pass it back to the CfExecute call
		/// in order to perform the desired operation on the file/directory.
		/// </summary>
		public CF_TRANSFER_KEY TransferKey;

		/// <summary>
		/// A numeric scale given to the sync provider to describe the relative priority of one fetch compared to another fetch, in
		/// order to provide the most responsive experience to the user. The values range from 0 (lowest possible priority) to 15
		/// (highest possible priority).
		/// </summary>
		public byte PriorityHint;

		/// <summary>An optional correlation vector.</summary>
		public IntPtr CorrelationVector;

		/// <summary>Points to a structure that contains the information about the user process that triggers this callback.</summary>
		public IntPtr ProcessInfo;

		/// <summary/>
		public CF_REQUEST_KEY RequestKey;
	}

	/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_callback_parameters typedef struct CF_CALLBACK_PARAMETERS {
	// ULONG ParamSize; union { struct { CF_CALLBACK_CANCEL_FLAGS Flags; union { struct { LARGE_INTEGER FileOffset; LARGE_INTEGER
	// Length; } FetchData; } DUMMYUNIONNAME; } Cancel; struct { CF_CALLBACK_FETCH_DATA_FLAGS Flags; LARGE_INTEGER RequiredFileOffset;
	// LARGE_INTEGER RequiredLength; LARGE_INTEGER OptionalFileOffset; LARGE_INTEGER OptionalLength; LARGE_INTEGER LastDehydrationTime;
	// CF_CALLBACK_DEHYDRATION_REASON LastDehydrationReason; } FetchData; struct { CF_CALLBACK_VALIDATE_DATA_FLAGS Flags; LARGE_INTEGER
	// RequiredFileOffset; LARGE_INTEGER RequiredLength; } ValidateData; struct { CF_CALLBACK_FETCH_PLACEHOLDERS_FLAGS Flags; PCWSTR
	// Pattern; } FetchPlaceholders; struct { CF_CALLBACK_OPEN_COMPLETION_FLAGS Flags; } OpenCompletion; struct {
	// CF_CALLBACK_CLOSE_COMPLETION_FLAGS Flags; } CloseCompletion; struct { CF_CALLBACK_DEHYDRATE_FLAGS Flags;
	// CF_CALLBACK_DEHYDRATION_REASON Reason; } Dehydrate; struct { CF_CALLBACK_DEHYDRATE_COMPLETION_FLAGS Flags;
	// CF_CALLBACK_DEHYDRATION_REASON Reason; } DehydrateCompletion; struct { CF_CALLBACK_DELETE_FLAGS Flags; } Delete; struct {
	// CF_CALLBACK_DELETE_COMPLETION_FLAGS Flags; } DeleteCompletion; struct { CF_CALLBACK_RENAME_FLAGS Flags; PCWSTR TargetPath; }
	// Rename; struct { CF_CALLBACK_RENAME_COMPLETION_FLAGS Flags; PCWSTR SourcePath; } RenameCompletion; } DUMMYUNIONNAME; } CF_CALLBACK_PARAMETERS;
	[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_CALLBACK_PARAMETERS
	{
		/// <summary/>
		public uint ParamSize;

		private readonly uint pad;

		/// <summary/>
		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 56)]
		public byte[] Content;

		/// <summary/>
		public readonly CANCEL Cancel => GetParam<CANCEL>();

		/// <summary/>
		public readonly FETCHDATA FetchData => GetParam<FETCHDATA>();

		/// <summary/>
		public readonly VALIDATEDATA ValidateData => GetParam<VALIDATEDATA>();

		/// <summary/>
		public readonly FETCHPLACEHOLDERS FetchPlaceholders => GetParam<FETCHPLACEHOLDERS>();

		/// <summary/>
		public readonly OPENCOMPLETION OpenCompletion => GetParam<OPENCOMPLETION>();

		/// <summary/>
		public readonly CLOSECOMPLETION CloseCompletion => GetParam<CLOSECOMPLETION>();

		/// <summary/>
		public readonly DEHYDRATE Dehydrate => GetParam<DEHYDRATE>();

		/// <summary/>
		public readonly DEHYDRATECOMPLETION DehydrateCompletion => GetParam<DEHYDRATECOMPLETION>();

		/// <summary/>
		public readonly DELETE Delete => GetParam<DELETE>();

		/// <summary/>
		public readonly DELETECOMPLETION DeleteCompletion => GetParam<DELETECOMPLETION>();

		/// <summary/>
		public readonly RENAME Rename => GetParam<RENAME>();

		/// <summary/>
		public readonly RENAMECOMPLETION RenameCompletion => GetParam<RENAMECOMPLETION>();

		/// <summary>Gets the parameter value for this structure.</summary>
		/// <typeparam name="T">The type of the structure to retrieve.</typeparam>
		/// <returns>The requested structure.</returns>
		public readonly T GetParam<T>() where T : struct
		{
			using var ptr = new PinnedObject(Content);
			return ((IntPtr)ptr).ToStructure<T>();
		}

		/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
		[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
		[StructLayout(LayoutKind.Sequential, Pack = 8)]
		public struct CANCEL
		{
			/// <summary>Cancel data flags.</summary>
			public CF_CALLBACK_CANCEL_FLAGS Flags;

			/// <summary/>
			public CANCELFETCHDATA FetchData;

			/// <summary/>
			[StructLayout(LayoutKind.Sequential)]
			public struct CANCELFETCHDATA
			{
				/// <summary>Offset, in bytes, for specifying the range of data.</summary>
				public long FileOffset;

				/// <summary>Length of the data in bytes.</summary>
				public long Length;
			}
		}

		/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
		[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CLOSECOMPLETION
		{
			/// <summary>Placeholder close completion flags.</summary>
			public CF_CALLBACK_CLOSE_COMPLETION_FLAGS Flags;
		}

		/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
		[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
		[StructLayout(LayoutKind.Sequential)]
		public struct DEHYDRATE
		{
			/// <summary>Placeholder dehydration flags.</summary>
			public CF_CALLBACK_DEHYDRATE_FLAGS Flags;

			/// <summary/>
			public CF_CALLBACK_DEHYDRATION_REASON Reason;
		}

		/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
		[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
		[StructLayout(LayoutKind.Sequential)]
		public struct DEHYDRATECOMPLETION
		{
			/// <summary/>
			public CF_CALLBACK_DEHYDRATE_COMPLETION_FLAGS Flags;

			/// <summary/>
			public CF_CALLBACK_DEHYDRATION_REASON Reason;
		}

		/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
		[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
		[StructLayout(LayoutKind.Sequential)]
		public struct DELETE
		{
			/// <summary>Placeholder deletion flags.</summary>
			public CF_CALLBACK_DELETE_FLAGS Flags;
		}

		/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
		[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
		[StructLayout(LayoutKind.Sequential)]
		public struct DELETECOMPLETION
		{
			/// <summary>Placeholder deletion complete flags.</summary>
			public CF_CALLBACK_DELETE_COMPLETION_FLAGS Flags;
		}

		/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
		[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
		[StructLayout(LayoutKind.Sequential)]
		public struct FETCHDATA
		{
			/// <summary>Fetch data flags.</summary>
			public CF_CALLBACK_FETCH_DATA_FLAGS Flags;

			/// <summary>Offset, in bytes, for specifying the required range of data.</summary>
			public long RequiredFileOffset;

			/// <summary>Length of the required data to retrieve, in bytes.</summary>
			public long RequiredLength;

			/// <summary>
			/// Offset, in bytes, of a broader piece of data to provide to a sync provider. This is optional and can be used if the sync
			/// provider prefers to work with larger segments of data.
			/// </summary>
			public long OptionalFileOffset;

			/// <summary>
			/// Length, in bytes, of a broader piece of data to provide to a sync provider. This is optional and can be used if the sync
			/// provider prefers to work with larger segments of data.
			/// </summary>
			public long OptionalLength;

			/// <summary/>
			public long LastDehydrationTime;

			/// <summary/>
			public CF_CALLBACK_DEHYDRATION_REASON LastDehydrationReason;
		}

		/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
		[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
		[StructLayout(LayoutKind.Sequential)]
		public struct FETCHPLACEHOLDERS
		{
			/// <summary>Flags for fetching placeholder metadata.</summary>
			public CF_CALLBACK_FETCH_PLACEHOLDERS_FLAGS Flags;

			/// <summary>
			/// A standard Windows file pattern which may contain wildcard characters (‘?’, ‘*’). All placeholders information matching the
			/// pattern must be transferred, but not necessarily in one-shot, as a minimum requirement. Alternatively, a sync provider may
			/// choose to not transfer placeholders matching the pattern.
			/// </summary>
			[MarshalAs(UnmanagedType.LPWStr)]
			public string Pattern;
		}

		/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
		[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
		[StructLayout(LayoutKind.Sequential)]
		public struct OPENCOMPLETION
		{
			/// <summary>Placeholder open completion flags.</summary>
			public CF_CALLBACK_OPEN_COMPLETION_FLAGS Flags;
		}

		/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
		[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
		[StructLayout(LayoutKind.Sequential)]
		public struct RENAME
		{
			/// <summary>Rename placeholder flags.</summary>
			public CF_CALLBACK_RENAME_FLAGS Flags;

			/// <summary>The full rename/move target path relative to the volume.</summary>
			[MarshalAs(UnmanagedType.LPWStr)]
			public string TargetPath;
		}

		/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
		[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
		[StructLayout(LayoutKind.Sequential)]
		public struct RENAMECOMPLETION
		{
			/// <summary>Rename completion placeholder flags.</summary>
			public CF_CALLBACK_RENAME_COMPLETION_FLAGS Flags;

			/// <summary>The full source link path relative to the volume.</summary>
			[MarshalAs(UnmanagedType.LPWStr)]
			public string SourcePath;
		}

		/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
		[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
		[StructLayout(LayoutKind.Sequential)]
		public struct VALIDATEDATA
		{
			/// <summary>Data validation flags.</summary>
			public CF_CALLBACK_VALIDATE_DATA_FLAGS Flags;

			/// <summary>Offset, in bytes, for specifying the range of data to validate.</summary>
			public long RequiredFileOffset;

			/// <summary>Length, in bytes, of the data to validate.</summary>
			public long RequiredLength;
		}
	}

	/// <summary>The callbacks to be registered by the sync provider.</summary>
	/// <remarks>
	/// <para>
	/// This callback registration is how a sync provider communicates to the library which functions to call to execute various
	/// requests from the platform.
	/// </para>
	/// <para>
	/// Note that the sync provider only needs to register implemented callbacks, and <c>CF_CALLBACK_REGISTRATION</c> should always end
	/// with <c>CF_CALLBACK_REGISTRATION_END</c>.
	/// </para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_callback_registration typedef struct
	// CF_CALLBACK_REGISTRATION { CF_CALLBACK_TYPE Type; CF_CALLBACK Callback; } CF_CALLBACK_REGISTRATION;
	[PInvokeData("cfapi.h", MSDNShortId = "F1633983-DAB2-4072-AA9E-DC7015E6B988")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_CALLBACK_REGISTRATION
	{
		/// <summary>The type of callback to be registered.</summary>
		public CF_CALLBACK_TYPE Type;

		/// <summary>A pointer to the callback function.</summary>
		[MarshalAs(UnmanagedType.FunctionPtr)]
		public CF_CALLBACK Callback;

		/// <summary>An instance of <c>CF_CALLBACK_REGISTRATION</c> that indicates the end of the registration list.</summary>
		public static readonly CF_CALLBACK_REGISTRATION CF_CALLBACK_REGISTRATION_END = new() { Type = CF_CALLBACK_TYPE.CF_CALLBACK_TYPE_NONE };
	}

	/// <summary>Opaque handle to a connection key.</summary>
	[PInvokeData("cfapi.h")]
	[StructLayout(LayoutKind.Sequential)]
	public readonly struct CF_CONNECTION_KEY
	{
		private readonly long Internal;
	}

	/// <summary>Specifies a range of data in a placeholder file.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_file_range typedef struct CF_FILE_RANGE { LARGE_INTEGER
	// StartingOffset; LARGE_INTEGER Length; } CF_FILE_RANGE;
	[PInvokeData("cfapi.h", MSDNShortId = "DAE43446-725E-490B-AE1B-EA6CB31F4358")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_FILE_RANGE
	{
		/// <summary>The offset of the starting point of the data.</summary>
		public long StartingOffset;

		/// <summary>The length of the data, in bytes.</summary>
		public long Length;
	}

	/// <summary>A structure to describe the location and range of data in a file.</summary>
	// https://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/mt844616(v=vs.85) typedef struct __CF_FILE_RANGE_BUFFER
	// { LARGE_INTEGER FileOffset; LARGE_INTEGER Length; } CF_FILE_RANGE_BUFFER;
	[PInvokeData("CfApi.h")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_FILE_RANGE_BUFFER
	{
		/// <summary>The offset of the range of data within a file.</summary>
		public long FileOffset;

		/// <summary>The length, in bytes of the data range.</summary>
		public long Length;
	}

	/// <summary>Placeholder file or directory metadata.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_fs_metadata typedef struct CF_FS_METADATA { FILE_BASIC_INFO
	// BasicInfo; LARGE_INTEGER FileSize; } CF_FS_METADATA;
	[PInvokeData("cfapi.h", MSDNShortId = "A6D4473A-C93A-4B56-9EB0-9B44A56E5D28")]
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
	public struct CF_FS_METADATA
	{
		/// <summary>Basic file information.</summary>
		public FILE_BASIC_INFO BasicInfo;

		/// <summary>The size of the file, in bytes.</summary>
		public long FileSize;
	}

	/// <summary>Specifies the primary hydration policy and its modifier.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_hydration_policy typedef struct CF_HYDRATION_POLICY {
	// CF_HYDRATION_POLICY_PRIMARY_USHORT Primary; CF_HYDRATION_POLICY_MODIFIER_USHORT Modifier; } CF_HYDRATION_POLICY;
	[PInvokeData("cfapi.h", MSDNShortId = "1541E108-7AE4-4899-8940-94FD264C1B10")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_HYDRATION_POLICY
	{
		/// <summary>The primary hydration policy.</summary>
		public CF_HYDRATION_POLICY_PRIMARY Primary;

		/// <summary>The hydration policy modifier.</summary>
		public CF_HYDRATION_POLICY_MODIFIER Modifier;
	}

	/// <summary>Information about an operation on a placeholder file or folder.</summary>
	/// <remarks>
	/// The platform provides the <c>ConnectionKey</c>, <c>TransferKey</c>, and <c>CorrelationVector</c> to all callback functions
	/// registered via CfConnectSyncRoot. Additionally, sync providers can obtain a <c>TransferKey</c> using CfGetTransferKey and a
	/// <c>CorrelationVector</c> using CfGetCorrelationVector.
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_operation_info typedef struct CF_OPERATION_INFO { ULONG
	// StructSize; CF_OPERATION_TYPE Type; CF_CONNECTION_KEY ConnectionKey; CF_TRANSFER_KEY TransferKey; const CORRELATION_VECTOR
	// *CorrelationVector; const CF_SYNC_STATUS *SyncStatus; CF_REQUEST_KEY RequestKey; } CF_OPERATION_INFO;
	[PInvokeData("cfapi.h", MSDNShortId = "4AE9A968-1325-4EFF-8F5B-8F465740B0C4")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_OPERATION_INFO
	{
		/// <summary>The size of the structure.</summary>
		public uint StructSize;

		/// <summary>The type of operation performed.</summary>
		public CF_OPERATION_TYPE Type;

		/// <summary>A connection key obtained for the communication channel.</summary>
		public CF_CONNECTION_KEY ConnectionKey;

		/// <summary>An opaque handle to the placeholder.</summary>
		public CF_TRANSFER_KEY TransferKey;

		/// <summary>A correlation vector on a placeholder used for telemetry purposes.</summary>
		public IntPtr CorrelationVector;

		/// <summary>
		/// <para><c>Note</c> This member is new for Windows 10, version 1803.</para>
		/// <para>The current sync status of the platform.</para>
		/// <para>
		/// The platform queries this information upon any failed operations on a cloud file placeholder. If a structure is available,
		/// the platform will use the information provided to construct a more meaningful and actionable message to the user. The
		/// platform will keep this information on the file until the last handle on it goes away. If <c>null</c>, the platform will
		/// clear the previously set sync status, if there is one.
		/// </para>
		/// </summary>
		public IntPtr SyncStatus;

		/// <summary/>
		public CF_REQUEST_KEY RequestKey;
	}

	/// <summary>Parameters of an operation on a placeholder file or folder.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_operation_parameters typedef struct CF_OPERATION_PARAMETERS
	// { ULONG ParamSize; union { struct { CF_OPERATION_TRANSFER_DATA_FLAGS Flags; NTSTATUS CompletionStatus; LPCVOID Buffer;
	// LARGE_INTEGER Offset; LARGE_INTEGER Length; } TransferData; struct { CF_OPERATION_RETRIEVE_DATA_FLAGS Flags; LPVOID Buffer;
	// LARGE_INTEGER Offset; LARGE_INTEGER Length; LARGE_INTEGER ReturnedLength; } RetrieveData; struct { CF_OPERATION_ACK_DATA_FLAGS
	// Flags; NTSTATUS CompletionStatus; LARGE_INTEGER Offset; LARGE_INTEGER Length; } AckData; struct {
	// CF_OPERATION_RESTART_HYDRATION_FLAGS Flags; const CF_FS_METADATA *FsMetadata; LPCVOID FileIdentity; DWORD FileIdentityLength; }
	// RestartHydration; struct { CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAGS Flags; NTSTATUS CompletionStatus; LARGE_INTEGER
	// PlaceholderTotalCount; CF_PLACEHOLDER_CREATE_INFO *PlaceholderArray; DWORD PlaceholderCount; DWORD EntriesProcessed; }
	// TransferPlaceholders; struct { CF_OPERATION_ACK_DEHYDRATE_FLAGS Flags; NTSTATUS CompletionStatus; LPCVOID FileIdentity; DWORD
	// FileIdentityLength; } AckDehydrate; struct { CF_OPERATION_ACK_RENAME_FLAGS Flags; NTSTATUS CompletionStatus; } AckRename; struct
	// { CF_OPERATION_ACK_DELETE_FLAGS Flags; NTSTATUS CompletionStatus; } AckDelete; } DUMMYUNIONNAME; } CF_OPERATION_PARAMETERS;
	[PInvokeData("cfapi.h", MSDNShortId = "668C682E-47C2-41BC-A4F9-AA2F2B516F54")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_OPERATION_PARAMETERS
	{
		/// <summary/>
		public uint ParamSize;

		// Yes, this is strange, but needed to deal with struct size changing based on pointer size (40/48).
		private readonly uint pad4_8;
		private readonly ulong pad8_16;
		private readonly ulong pad16_24;
		private readonly ulong pad24_32;
		private readonly IntPtr padp1;
		private readonly IntPtr padp2;

		/// <summary/>
		public readonly TRANSFERDATA TransferData { get => GetParam<TRANSFERDATA>(); set => SetParam(value); }

		/// <summary/>
		public readonly RETRIEVEDATA RetrieveData { get => GetParam<RETRIEVEDATA>(); set => SetParam(value); }

		/// <summary/>
		public readonly ACKDATA AckData { get => GetParam<ACKDATA>(); set => SetParam(value); }

		/// <summary/>
		public readonly RESTARTHYDRATION RestartHydration { get => GetParam<RESTARTHYDRATION>(); set => SetParam(value); }

		/// <summary/>
		public readonly TRANSFERPLACEHOLDERS TransferPlaceholders { get => GetParam<TRANSFERPLACEHOLDERS>(); set => SetParam(value); }

		/// <summary/>
		public readonly ACKDEHYDRATE AckDehydrate { get => GetParam<ACKDEHYDRATE>(); set => SetParam(value); }

		/// <summary/>
		public readonly ACKRENAME AckRename { get => GetParam<ACKRENAME>(); set => SetParam(value); }

		/// <summary/>
		public readonly ACKDELETE AckDelete { get => GetParam<ACKDELETE>(); set => SetParam(value); }

		/// <summary>Gets the parameter value for this structure.</summary>
		/// <typeparam name="T">The type of the structure to retrieve.</typeparam>
		/// <returns>The requested structure.</returns>
		public readonly unsafe T GetParam<T>() where T : struct
		{
			using var ptr = new PinnedObject(this);
			return ((IntPtr)ptr).ToStructure<T>(Marshal.SizeOf<CF_OPERATION_PARAMETERS>(), 8);
		}

		/// <summary>Sets the parameter value for this structure.</summary>
		/// <typeparam name="T">The type of the structure to set.</typeparam>
		/// <param name="value">The value to set.</param>
		public readonly void SetParam<T>(T value) where T : struct
		{
			unsafe
			{
				fixed (ulong* p = &pad8_16)
				{
					((IntPtr)(void*)p).Write(value, 0, Marshal.SizeOf<CF_OPERATION_PARAMETERS>() - 8);
				}
			}
		}

		/// <summary>Creates a CF_OPERATION_PARAMETERS instance with the specified parameter value.</summary>
		/// <typeparam name="T">The parameter type.</typeparam>
		/// <param name="paramValue">The parameter value.</param>
		/// <returns>A CF_OPERATION_PARAMETERS instance initialized with <paramref name="paramValue"/> and the correct ParamSize.</returns>
		public static CF_OPERATION_PARAMETERS Create<T>(T paramValue = default) where T : struct
		{
			var op = new CF_OPERATION_PARAMETERS { ParamSize = CF_SIZE_OF_OP_PARAM<T>() };
			op.SetParam(paramValue);
			return op;
		}

		/// <summary>Gets the size value used in ParamSize given a specific parameter type.</summary>
		/// <typeparam name="T">The parameter type.</typeparam>
		/// <returns>The size of the structure.</returns>
		public static uint CF_SIZE_OF_OP_PARAM<T>() where T : struct => (uint)(Marshal.OffsetOf<CF_OPERATION_PARAMETERS>(nameof(pad8_16)).ToInt32() + Marshal.SizeOf<T>());

		/// <summary/>
		[StructLayout(LayoutKind.Sequential)]
		public struct TRANSFERDATA
		{
			/// <summary>Flags for transferring data.</summary>
			public CF_OPERATION_TRANSFER_DATA_FLAGS Flags;

			/// <summary>Status for transferring data. Set to STATUS_SUCCESS if the sync provider will transfer data to a placeholder.</summary>
			public NTStatus CompletionStatus;

			/// <summary>A valid user mode buffer.</summary>
			public IntPtr Buffer;

			/// <summary>The offset used with the <c>Length</c> to describe a range in the placeholder to which the data is transferred.</summary>
			public long Offset;

			/// <summary>The length in bytes of the <c>Buffer</c>.</summary>
			public long Length;
		}

		/// <summary/>
		[StructLayout(LayoutKind.Sequential)]
		public struct RETRIEVEDATA
		{
			/// <summary>Flags for retrieving data.</summary>
			public CF_OPERATION_RETRIEVE_DATA_FLAGS Flags;

			/// <summary/>
			public IntPtr Buffer;

			/// <summary>The offset used with the <c>Length</c> to describe the range of data retrieved from a placeholder.</summary>
			public long Offset;

			/// <summary>The length in bytes of the <c>Buffer</c>.</summary>
			public long Length;

			/// <summary>The number of bytes retrieved on successful completion.</summary>
			public long ReturnedLength;
		}

		/// <summary/>
		[StructLayout(LayoutKind.Sequential)]
		public struct ACKDATA
		{
			/// <summary>Flags for acknowledging data.</summary>
			public CF_OPERATION_ACK_DATA_FLAGS Flags;

			/// <summary>
			/// <para>Completion status of data acknowledgement.</para>
			/// <para>Set to STATUS_SUCCESS if the sync provider validates the data within the range to be acknowledged is good.</para>
			/// </summary>
			public NTStatus CompletionStatus;

			/// <summary>The offset in bytes of the placeholder data to be acknowledged.</summary>
			public long Offset;

			/// <summary>The length in bytes of data in the placeholder to be acknowledged.</summary>
			public long Length;
		}

		/// <summary/>
		[StructLayout(LayoutKind.Sequential)]
		public struct RESTARTHYDRATION
		{
			/// <summary>Flags to restart placeholder hydration.</summary>
			public CF_OPERATION_RESTART_HYDRATION_FLAGS Flags;

			/// <summary>Optional. Contains updates to the files metadata.</summary>
			public IntPtr FsMetadata;

			/// <summary>Optional. When provided, the file identity is updated to this value. Otherwise, it remains the same.</summary>
			public IntPtr FileIdentity;

			/// <summary>Optional. This specifies the length of the <c>FileIdentity</c>.</summary>
			public uint FileIdentityLength;
		}

		/// <summary/>
		[StructLayout(LayoutKind.Sequential)]
		public struct TRANSFERPLACEHOLDERS
		{
			/// <summary>Flags for transferring placeholders.</summary>
			public CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAGS Flags;

			/// <summary>The completion status of the operation.</summary>
			public NTStatus CompletionStatus;

			/// <summary>Total number of placeholders.</summary>
			public long PlaceholderTotalCount;

			/// <summary>An array of placeholders to be transferred.</summary>
			public IntPtr PlaceholderArray;

			/// <summary>The number of placeholders being transferred.</summary>
			public uint PlaceholderCount;

			/// <summary>The placeholder entries that have been processed.</summary>
			public uint EntriesProcessed;
		}

		/// <summary/>
		[StructLayout(LayoutKind.Sequential)]
		public struct ACKDEHYDRATE
		{
			/// <summary>Dehydrated data acknowledgment flags.</summary>
			public CF_OPERATION_ACK_DEHYDRATE_FLAGS Flags;

			/// <summary>The completion status of the operation.</summary>
			public NTStatus CompletionStatus;

			/// <summary>The file identity of the placeholder file to acknowledge dehydrated data for.</summary>
			public IntPtr FileIdentity;

			/// <summary>Length, in bytes, of the <c>FileIdentity</c>.</summary>
			public uint FileIdentityLength;
		}

		/// <summary/>
		[StructLayout(LayoutKind.Sequential)]
		public struct ACKRENAME
		{
			/// <summary>Acknowledge rename placeholder flags.</summary>
			public CF_OPERATION_ACK_RENAME_FLAGS Flags;

			/// <summary>The completion status of the operation.</summary>
			public NTStatus CompletionStatus;
		}

		/// <summary/>
		[StructLayout(LayoutKind.Sequential)]
		public struct ACKDELETE
		{
			/// <summary>Acknowledge delete flags.</summary>
			public CF_OPERATION_ACK_DELETE_FLAGS Flags;

			/// <summary>The completion status of the operation.</summary>
			public NTStatus CompletionStatus;
		}
	}

	/// <summary>Basic placeholder information.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_placeholder_basic_info typedef struct
	// CF_PLACEHOLDER_BASIC_INFO { CF_PIN_STATE PinState; CF_IN_SYNC_STATE InSyncState; LARGE_INTEGER FileId; LARGE_INTEGER
	// SyncRootFileId; ULONG FileIdentityLength; BYTE FileIdentity[1]; } CF_PLACEHOLDER_BASIC_INFO;
	[PInvokeData("cfapi.h", MSDNShortId = "77367235-342D-4BBC-B910-FE798E14B588")]
	[VanaraMarshaler(typeof(SafeAnysizeStructMarshaler<CF_PLACEHOLDER_BASIC_INFO>), nameof(FileIdentityLength))]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_PLACEHOLDER_BASIC_INFO
	{
		/// <summary>The pin state of the placeholder. See CfSetPinState for more details.</summary>
		public CF_PIN_STATE PinState;

		/// <summary>The in-sync state of the placeholder. see CfSetInSyncState for more details.</summary>
		public CF_IN_SYNC_STATE InSyncState;

		/// <summary>A 64-bit volume wide non-volatile number that uniquely identifies a file or directory.</summary>
		public long FileId;

		/// <summary>The file ID of the sync root directory that contains the file whose placeholder information is to be queried.</summary>
		public long SyncRootFileId;

		/// <summary>Length, in bytes, of the FileIdentity.</summary>
		public uint FileIdentityLength;

		/// <summary/>
		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
		public byte[] FileIdentity;
	}

	/// <summary>Contains placeholder information for creating new placeholder files or directories.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_placeholder_create_info typedef struct
	// CF_PLACEHOLDER_CREATE_INFO { LPCWSTR RelativeFileName; CF_FS_METADATA FsMetadata; LPCVOID FileIdentity; DWORD FileIdentityLength;
	// CF_PLACEHOLDER_CREATE_FLAGS Flags; HRESULT Result; USN CreateUsn; } CF_PLACEHOLDER_CREATE_INFO;
	[PInvokeData("cfapi.h", MSDNShortId = "2DC1FF5F-FBFD-45CA-8CD5-B2F586C22778")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_PLACEHOLDER_CREATE_INFO
	{
		/// <summary>The name of the child placeholder file or directory to be created.</summary>
		[MarshalAs(UnmanagedType.LPWStr)] public string RelativeFileName;

		/// <summary>File system metadata to be created with the placeholder.</summary>
		public CF_FS_METADATA FsMetadata;

		/// <summary>
		/// A user mode buffer containing file information supplied by the sync provider. This is required for files (not for directories).
		/// </summary>
		public IntPtr FileIdentity;

		/// <summary>Length, in bytes, of the <c>FileIdentity</c>.</summary>
		public uint FileIdentityLength;

		/// <summary>Flags for specifying placeholder creation behavior.</summary>
		public CF_PLACEHOLDER_CREATE_FLAGS Flags;

		/// <summary>The result of placeholder creation. On successful creation, the value is: STATUS_OK.</summary>
		public HRESULT Result;

		/// <summary>The final USN value after create actions are performed.</summary>
		public USN CreateUsn;

		/// <summary>
		/// Initializes a new instance of the <see cref="CF_PLACEHOLDER_CREATE_INFO"/> struct with info from a file.
		/// </summary>
		/// <param name="fileInfo">The file information.</param>
		public CF_PLACEHOLDER_CREATE_INFO(System.IO.FileInfo fileInfo) : this()
		{
			RelativeFileName = fileInfo.FullName;
			FsMetadata = new CF_FS_METADATA
			{
				FileSize = fileInfo.Length,
				BasicInfo = new FILE_BASIC_INFO
				{
					FileAttributes = (FileFlagsAndAttributes)fileInfo.Attributes,
					CreationTime = fileInfo.CreationTime.ToFileTimeStruct(),
					LastWriteTime = fileInfo.LastWriteTime.ToFileTimeStruct(),
					LastAccessTime = fileInfo.LastAccessTime.ToFileTimeStruct(),
					ChangeTime = fileInfo.LastWriteTime.ToFileTimeStruct()
				}
			};
		}
	}

	/// <summary>Standard placeholder information.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_placeholder_standard_info typedef struct
	// CF_PLACEHOLDER_STANDARD_INFO { LARGE_INTEGER OnDiskDataSize; LARGE_INTEGER ValidatedDataSize; LARGE_INTEGER ModifiedDataSize;
	// LARGE_INTEGER PropertiesSize; CF_PIN_STATE PinState; CF_IN_SYNC_STATE InSyncState; LARGE_INTEGER FileId; LARGE_INTEGER
	// SyncRootFileId; ULONG FileIdentityLength; BYTE FileIdentity[1]; } CF_PLACEHOLDER_STANDARD_INFO;
	[PInvokeData("cfapi.h", MSDNShortId = "F0CDC9CD-7D31-4854-9568-8F13516C6D15")]
	[VanaraMarshaler(typeof(SafeAnysizeStructMarshaler<CF_PLACEHOLDER_STANDARD_INFO>), nameof(FileIdentityLength))]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_PLACEHOLDER_STANDARD_INFO
	{
		/// <summary>Total number of bytes on disk.</summary>
		public long OnDiskDataSize;

		/// <summary>Total number of bytes in sync with the cloud.</summary>
		public long ValidatedDataSize;

		/// <summary>Total number of bytes that have been overwritten/appended locally that are not in sync with the cloud.</summary>
		public long ModifiedDataSize;

		/// <summary>Total number of bytes on disk that are used by all the property blobs.</summary>
		public long PropertiesSize;

		/// <summary>The pin state of the placeholder. See CfSetPinState for more details.</summary>
		public CF_PIN_STATE PinState;

		/// <summary>The in-sync state of the placeholder. see CfSetInSyncState for more details.</summary>
		public CF_IN_SYNC_STATE InSyncState;

		/// <summary>A 64-bit volume wide non-volatile number that uniquely identifies a file or directory.</summary>
		public long FileId;

		/// <summary>The file ID of the sync root directory that contains the file whose placeholder information is to be queried.</summary>
		public long SyncRootFileId;

		/// <summary>Length, in bytes, of the FileIdentity.</summary>
		public uint FileIdentityLength;

		/// <summary/>
		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
		public byte[] FileIdentity;
	}

	/// <summary>
	/// Returns information for the cloud files platform. This is intended for sync providers running on multiple versions of Windows.
	/// </summary>
	/// <remarks>
	/// <para>
	/// The platform is a combination of the cloud filter and the placeholder files API library, which are always kept in sync with each
	/// other. This API is intended for sync providers that need to make decisions based on the platform capabilities of multiple
	/// versions of Windows.
	/// </para>
	/// <para>If you are building an app that uses or is aware of placeholder files, this may be useful to you.</para>
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_platform_info typedef struct CF_PLATFORM_INFO { DWORD
	// BuildNumber; DWORD RevisionNumber; DWORD IntegrationNumber; } CF_PLATFORM_INFO;
	[PInvokeData("cfapi.h", MSDNShortId = "BEB1CBF0-05FB-4D48-AC43-AA957F2208DB")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_PLATFORM_INFO
	{
		/// <summary>The build number of the Windows platform version. Changes when the platform is serviced by a Windows update.</summary>
		public uint BuildNumber;

		/// <summary>The revision number of the Windows platform version. Changes when the platform is serviced by a Windows update.</summary>
		public uint RevisionNumber;

		/// <summary>
		/// The integration number of the Windows platform version. This is indicative of the platform capabilities, both in terms of
		/// API contracts and availability of bug fixes.
		/// </summary>
		public uint IntegrationNumber;
	}

	/// <summary>Specifies the primary population policy and its modifier.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_population_policy typedef struct CF_POPULATION_POLICY {
	// CF_POPULATION_POLICY_PRIMARY_USHORT Primary; CF_POPULATION_POLICY_MODIFIER_USHORT Modifier; } CF_POPULATION_POLICY;
	[PInvokeData("cfapi.h", MSDNShortId = "043EBBF8-4077-429B-B959-55E0623520E2")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_POPULATION_POLICY
	{
		/// <summary>The primary population policy.</summary>
		public CF_POPULATION_POLICY_PRIMARY Primary;

		/// <summary>The population policy modifier.</summary>
		public CF_POPULATION_POLICY_MODIFIER Modifier;
	}

	/// <summary>Contains information about a user process.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_process_info typedef struct CF_PROCESS_INFO { DWORD
	// StructSize; DWORD ProcessId; PCWSTR ImagePath; PCWSTR PackageName; PCWSTR ApplicationId; PCWSTR CommandLine; DWORD SessionId; } CF_PROCESS_INFO;
	[PInvokeData("cfapi.h", MSDNShortId = "912433E9-DC49-41BA-85F7-1A0AF9F88159")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_PROCESS_INFO
	{
		/// <summary>The size of the structure.</summary>
		public uint StructSize;

		/// <summary>The 32 bit ID of the user process.</summary>
		public uint ProcessId;

		/// <summary>
		/// The absolute path of the main executable file including the volume name in the format of NT file path. If the platform
		/// failed to retrieve the image path, “UNKNOWN” will be returned.
		/// </summary>
		[MarshalAs(UnmanagedType.LPWStr)] public string ImagePath;

		/// <summary>Used for modern applications. The app package name.</summary>
		[MarshalAs(UnmanagedType.LPWStr)] public string PackageName;

		/// <summary>Used for modern applications. The application ID.</summary>
		[MarshalAs(UnmanagedType.LPWStr)] public string ApplicationId;

		/// <summary>
		/// <para><c>Note</c> This member was added in Windows 10, version 1803.</para>
		/// <para>Used to start the process. If the platform failed to retrieve the command line, “UNKNOWN” will be returned.</para>
		/// <para>SessionId</para>
		/// <para><c>Note</c> This member was added in Windows 10, version 1803.</para>
		/// <para>The 32bit ID of the session wherein the user process that triggers the callback resides.</para>
		/// </summary>
		[MarshalAs(UnmanagedType.LPWStr)] public string CommandLine;

		/// <summary/>
		public uint SessionId;
	}

	/// <summary>Opaque handle to a request key.</summary>
	[PInvokeData("cfapi.h")]
	[StructLayout(LayoutKind.Sequential)]
	public readonly struct CF_REQUEST_KEY
	{
		private readonly long Internal;
	}

	/// <summary>Defines the sync policies used by a sync root.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_sync_policies typedef struct CF_SYNC_POLICIES { ULONG
	// StructSize; CF_HYDRATION_POLICY Hydration; CF_POPULATION_POLICY Population; CF_INSYNC_POLICY InSync; CF_HARDLINK_POLICY HardLink;
	// } CF_SYNC_POLICIES;
	[PInvokeData("cfapi.h", MSDNShortId = "5BCD0958-1FED-4F97-A4B4-2EB354E85BF6")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_SYNC_POLICIES
	{
		/// <summary>The size of the CF_SYNC_POLICIES structure.</summary>
		public uint StructSize;

		/// <summary>The hydration policy.</summary>
		public CF_HYDRATION_POLICY Hydration;

		/// <summary>The population policy.</summary>
		public CF_POPULATION_POLICY Population;

		/// <summary>The in-sync policy.</summary>
		public CF_INSYNC_POLICY InSync;

		/// <summary>The hard link policy.</summary>
		public CF_HARDLINK_POLICY HardLink;
	}

	/// <summary>The details of the sync provider and sync root to be registered.</summary>
	/// <remarks>
	/// <c>SyncRootIdentity</c> and <c>SyncRootIdentityLength</c> are optional members. If not used, set <c>SyncRootIdentity</c> to
	/// <c>nullptr</c> and <c>SyncRootIdentityLength</c> to <c>0</c>. <c>FileIdentity</c> and <c>FileIdentityLength</c> are also
	/// optional and if not used should be set to <c>nullptr</c> and <c>0</c>, respectively.
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_sync_registration typedef struct CF_SYNC_REGISTRATION {
	// ULONG StructSize; LPCWSTR ProviderName; LPCWSTR ProviderVersion; LPCVOID SyncRootIdentity; DWORD SyncRootIdentityLength; LPCVOID
	// FileIdentity; DWORD FileIdentityLength; GUID ProviderId; } CF_SYNC_REGISTRATION;
	[PInvokeData("cfapi.h", MSDNShortId = "F4D535FA-A0F5-4B4E-8409-0DD13C78A94E")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_SYNC_REGISTRATION
	{
		/// <summary>The size of the structure.</summary>
		public uint StructSize;

		/// <summary>The name of the sync provider. This is a user friendly string with a maximum length of 255 characters.</summary>
		[MarshalAs(UnmanagedType.LPWStr)] public string ProviderName;

		/// <summary>The version of the sync provider. This is a user friendly string with a maximum length of 255 characters.</summary>
		[MarshalAs(UnmanagedType.LPWStr)] public string ProviderVersion;

		/// <summary>The sync root identity used by the provider. This member is optional with a maximum size of 64 KB.</summary>
		public IntPtr SyncRootIdentity;

		/// <summary>
		/// The length of the <c>SyncRootIdentity</c>. This member is optional and is only used if a <c>SyncRootIdentity</c> is provided.
		/// </summary>
		public uint SyncRootIdentityLength;

		/// <summary>An optional file identity. This member has a maximum size of 4 KB.</summary>
		public IntPtr FileIdentity;

		/// <summary>The length of the file identity.</summary>
		public uint FileIdentityLength;

		/// <summary/>
		public Guid ProviderId;
	}

	/// <summary>Basic sync root information.</summary>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_sync_root_basic_info typedef struct CF_SYNC_ROOT_BASIC_INFO
	// { LARGE_INTEGER SyncRootFileId; } CF_SYNC_ROOT_BASIC_INFO;
	[PInvokeData("cfapi.h", MSDNShortId = "7499D9DD-BAF6-449A-A34E-CEAE3EE10543")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_SYNC_ROOT_BASIC_INFO
	{
		/// <summary>The file ID of the sync root.</summary>
		public long SyncRootFileId;
	}

	/// <summary>Sync root provider information.</summary>
	/// <remarks><c>CF_MAX_PROVIDER_NAME_LENGTH</c> and <c>CF_MAX_PROVIDER_VERSION_LENGTH</c> are set to 255.</remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_sync_root_provider_info typedef struct
	// CF_SYNC_ROOT_PROVIDER_INFO { CF_SYNC_PROVIDER_STATUS ProviderStatus; WCHAR ProviderName[CF_MAX_PROVIDER_NAME_LENGTH + 1]; WCHAR
	// ProviderVersion[CF_MAX_PROVIDER_VERSION_LENGTH + 1]; } CF_SYNC_ROOT_PROVIDER_INFO;
	[PInvokeData("cfapi.h", MSDNShortId = "9EBC64B5-7FB3-41AA-BCB2-29B3E444B463")]
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct CF_SYNC_ROOT_PROVIDER_INFO
	{
		/// <summary>Status of the sync root provider.</summary>
		public CF_SYNC_PROVIDER_STATUS ProviderStatus;

		/// <summary/>
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = CF_MAX_PROVIDER_NAME_LENGTH + 1)]
		public string ProviderName;

		/// <summary/>
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = CF_MAX_PROVIDER_VERSION_LENGTH + 1)]
		public string ProviderVersion;
	}

	/// <summary>Standard sync root information.</summary>
	/// <remarks><c>CF_MAX_PROVIDER_NAME_LENGTH</c> and <c>CF_MAX_PROVIDER_VERSION_LENGTH</c> are set to 255.</remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_sync_root_standard_info typedef struct
	// CF_SYNC_ROOT_STANDARD_INFO { LARGE_INTEGER SyncRootFileId; CF_HYDRATION_POLICY HydrationPolicy; CF_POPULATION_POLICY
	// PopulationPolicy; CF_INSYNC_POLICY InSyncPolicy; CF_HARDLINK_POLICY HardLinkPolicy; CF_SYNC_PROVIDER_STATUS ProviderStatus; WCHAR
	// ProviderName[CF_MAX_PROVIDER_NAME_LENGTH + 1]; WCHAR ProviderVersion[CF_MAX_PROVIDER_VERSION_LENGTH + 1]; ULONG
	// SyncRootIdentityLength; BYTE SyncRootIdentity[1]; } CF_SYNC_ROOT_STANDARD_INFO;
	[PInvokeData("cfapi.h", MSDNShortId = "17E409FB-2997-432C-977F-BEBF53068B42")]
	[VanaraMarshaler(typeof(SafeAnysizeStructMarshaler<CF_SYNC_ROOT_STANDARD_INFO>), nameof(SyncRootIdentityLength))]
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct CF_SYNC_ROOT_STANDARD_INFO
	{
		/// <summary>File ID of the sync root.</summary>
		public long SyncRootFileId;

		/// <summary>Hydration policy of the sync root.</summary>
		public CF_HYDRATION_POLICY HydrationPolicy;

		/// <summary>Population policy of the sync root.</summary>
		public CF_POPULATION_POLICY PopulationPolicy;

		/// <summary>In-sync policy of the sync root.</summary>
		public CF_INSYNC_POLICY InSyncPolicy;

		/// <summary>Sync root hard linking policy.</summary>
		public CF_HARDLINK_POLICY HardLinkPolicy;

		/// <summary>Status of the sync root provider.</summary>
		public CF_SYNC_PROVIDER_STATUS ProviderStatus;

		/// <summary/>
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = CF_MAX_PROVIDER_NAME_LENGTH + 1)]
		public string ProviderName;

		/// <summary/>
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = CF_MAX_PROVIDER_VERSION_LENGTH + 1)]
		public string ProviderVersion;

		/// <summary>Length, in bytes, of the SyncRootIdentity.</summary>
		public uint SyncRootIdentityLength;

		/// <summary/>
		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
		public byte[] SyncRootIdentity;
	}

	/// <summary>Used in a CF_OPERATION_INFO structure to describe the status of a specified sync root.</summary>
	/// <remarks>
	/// If a null pointer is set in the <c>SyncStatus</c> field of a CF_OPERATION_INFO structure, the platform will clear the previously
	/// set sync status, if there is one.
	/// </remarks>
	// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_sync_status typedef struct CF_SYNC_STATUS { ULONG
	// StructSize; ULONG Code; ULONG DescriptionOffset; ULONG DescriptionLength; ULONG DeviceIdOffset; ULONG DeviceIdLength; } CF_SYNC_STATUS;
	[PInvokeData("cfapi.h", MSDNShortId = "F80CBBAE-605B-4C1E-BDA5-A4B155F9D079")]
	[StructLayout(LayoutKind.Sequential)]
	public struct CF_SYNC_STATUS
	{
		/// <summary>The size, in bytes, of the sync status structure, including the actual description string.</summary>
		public uint StructSize;

		/// <summary>
		/// <para>The use of this parameter is completely up to the sync provider that supports this rich sync status construct.</para>
		/// <para>For a particular sync provider, it is expected that there is a 1:1 mapping between the code and the description string.</para>
		/// <para>
		/// It is recommended that you use the highest bit order to describe the type of error code: 1 for an error-level code, and 0
		/// for an information-level code.
		/// </para>
		/// <para><c>Note</c><c>Code</c> is opaque to the platform, and is used only for tracking purposes.</para>
		/// </summary>
		public uint Code;

		/// <summary>
		/// The offset of the description string relative to the start of <c>CF_SYNC_STATUS</c>. It points to a localized
		/// null-terminated wide string that is expected to contain more meaningful and actionable information about the file in
		/// question. Sync providers are expected to balance the requirement of providing more actionable information and maintaining an
		/// as small as possible memory footprint.
		/// </summary>
		public uint DescriptionOffset;

		/// <summary>The size of the description string, in bytes, that includes the null terminator.</summary>
		public uint DescriptionLength;

		/// <summary/>
		public uint DeviceIdOffset;

		/// <summary/>
		public uint DeviceIdLength;
	}

	/// <summary>Opaque handle to a transfer key.</summary>
	[PInvokeData("cfapi.h")]
	[StructLayout(LayoutKind.Sequential)]
	public readonly struct CF_TRANSFER_KEY
	{
		private readonly long Internal;
	}

	public partial struct HCFFILE
	{
		/// <summary>Performs an implicit conversion from <see cref="HCFFILE"/> to <see cref="HFILE"/>.</summary>
		/// <param name="h">The <see cref="HCFFILE"/> instance to convert.</param>
		public static implicit operator HFILE(HCFFILE h) => h.handle;
	}

	public partial class SafeHCFFILE
	{
		/// <summary>Performs an implicit conversion from <see cref="SafeHCFFILE"/> to <see cref="HFILE"/>.</summary>
		/// <param name="h">The <see cref="SafeHCFFILE"/> instance to convert.</param>
		public static implicit operator HFILE(SafeHCFFILE h) => h.handle;
	}
}
